c# - una - view lenta mysql
¿Sería una mala forma poner llaves en la misma línea que la declaración para las declaraciones "si" de una sola línea? (21)
Así que sé que se considera una buena práctica incluir siempre llaves para if, for, etc, aunque son opcionales si solo hay una siguiente declaración, por la razón de que es más fácil hacer algo accidentalmente como:
if(something == true)
DoSomething();
DoSomethingElse();
al editar rápidamente el código si no colocas las llaves.
¿Qué pasa con algo como esto sin embargo:
if(something == true)
{ DoSomething(); }
De esta forma, aún ocupa menos líneas (que IMO aumenta la legibilidad) pero aún así es poco probable que accidentalmente cometa el error desde arriba.
Lo pregunto porque no creo que haya visto este estilo antes para if o loops, pero lo veo usado para getter y setter en propiedades C # como:
public string Name
{get;set;}
No preguntar qué es lo mejor, ya que es demasiado subjetivo, sino simplemente si esto se consideraría un estilo aceptable y, en caso negativo, por qué no.
De esta forma, ocupa menos líneas (lo que IMO aumenta la legibilidad)
No estoy de acuerdo con que tener menos saltos de línea aumente la legibilidad. El diseño del código debe hacer que su estructura sea más visible, no ocultarla.
A veces me gusta hacer el
if(obj != null) obj.method();
Pero es un placer culpable ... No creo que haga que el código sea más legible, entonces ¿por qué no seguir un patrón que todos los demás están usando? La única excepción que creo que es bastante importante es cuando muestra cómo es parte de un patrón más grande y ayuda al usuario a ver el patrón más fácilmente:
public executeMethodOn(String cmd) {
CommandObject co;
if("CmdObject1".equals(cmd)) co=new CmdObject1();
if("CmdObject2".equals(cmd)) co=new CmdObjec21();
co.executeMethod();
}
Hace que el patrón sea mucho más obvio y ayuda a las personas que intentan insertar una nueva funcionalidad a ver dónde debe ir.
Dicho esto, si alguna vez tienes un patrón así, probablemente lo estés haciendo mal. Tuve que hacer esto en un sistema que no tenía reflejo, pero traté REALMENTE DIFÍCIL de evitarlo, y si hubiera tenido reflejo, hubiera sido mucho mejor.
Cuando me encuentro con una instrucción if de una sola línea, generalmente omito los curlys y mantengo todo en la misma línea:
if (something == true) DoSomething();
Es rápido, fácil y ahorra espacio.
El espacio en blanco en forma de nuevas líneas, indentación, espaciado, alineación, etc. es un aspecto importante de la tipografía y se usa ampliamente para mejorar la legibilidad del texto en artículos, libros y sitios web. No estoy seguro de por qué no se aplicará lo mismo a la legibilidad del código.
Habiendo dicho eso, no hay nada de malo contigo y tu equipo usando tu estilo. Siempre y cuando todos estén de acuerdo.
En lugar de:
if(something == true)
{ DoSomething(); }
Hacer esto:
if(something == true) { DoSomething(); }
En realidad, yo prefiero
if (something == true)
if (something == false)
encima
if (something)
if (!something)
Para mí, el signo de exclamación es difícil de ver de un vistazo, por lo que es fácil pasar por alto. Sin embargo, tenga en cuenta que cuando codigo en Python, casi siempre prefiero:
if something:
if not something:
A menos que quiera distinguir Ninguno de, por ejemplo, lista vacía.
Mientras seas consecuente, no debería ser un problema. En una empresa anterior que era el escenario típico, pero en mi empresa actual prefieren tener llaves en líneas separadas.
Muchas personas han sugerido poner ambos en una sola línea. Esto puede aumentar la legibilidad, pero a costa de una menor capacidad de depuración en mi opinión. He recorrido un montón de código escrito de esta manera y es más difícil de depurar por eso.
Algunos depuradores e IDE podrían pasar por encima de las dos partes de una sola línea if -statement y mostrar claramente si la condición se evaluó como verdadera o no, pero muchos otros depuradores pueden tratarla como una sola línea, lo que dificulta determinar si el cuerpo del if -statement fue llamado.
Por ejemplo, el depurador VS2008 para el código C ++ pasará sobre esto como una sola línea, lo que dificulta determinar si se llamó a Foo ().
if (a==b) { Foo(); }
No hay problema allí ... de hecho, Visual Studio no pondrá ese código en su propia línea si intenta formatearlo automáticamente. Entonces, si eso es más legible para ti ... eres bueno.
No veo por qué no. También lo he usado para funciones cortas.
En el frente de estilo ofensivo, es mucho mejor que lo indescriptible:
if (something== true) {
DoSomething();
}
Pero, si bien estamos en el tema del estilo, es
if (something)
y
if (!something)
Nunca
if (something== true)
o
if (something== false)
Normalmente hago esto con ifs de una línea:
if($something) {
do_something();
}
La única excepción (lo hago Perl, no estoy seguro si este estilo está permitido en C #) es para controles de bucle, donde uso el estilo de una línea invertida:
THING:
for my $thing (1 .. 10) {
next THING if $thing % 3 == 0;
}
Con una buena coloración de sintaxis es posible hacer que esas líneas se destaquen de forma pronunciada.
Personalmente, me gusta que todos mis bloques tengan el mismo patrón. Siempre utilizo llaves para ifs y siempre comienzan una nueva línea. Me gusta el modismo para definir automáticamente las propiedades públicas de poner {get; conjunto; } en la misma línea. Siento que tener todos los bloques con una abrazadera en su propia línea mejora la legibilidad. Como otros han señalado, también lo hace más claro en el depurador si está pasando por encima de las líneas.
Si no estás de acuerdo, está bien, también, pero como otros han dicho, sé consistente. Con ese fin, es posible que desee compartir la configuración de "formato de código" entre usted y sus compañeros de trabajo para que el formato automático haga que todo sea coherente para todos.
Yo lo haría:
if (something)
{
DoSomething();
}
y
public string MyProperty { get; set; }
Si realmente desea guardar líneas de código, puede escribirlo así:
if(something == true) { DoSomething(); }
o esto, sin los refuerzos
if(something == true) DoSomething();
Si trabajas en equipo, necesitas crear un estándar.
Personalmente me gusta hacer:
if(foo)
DoSomething();
o
if(foo) DoSomething();
No veo un problema con no tener los apoyos. La razón por la que las personas citan, la que mencionas sobre agregar otra declaración en la línea a continuación, es una que nunca he visto.
Siempre y cuando lo haga de manera consistente, y se asegure de que todos los que trabajan en su código saben cómo lo hace, no importa lo que haga.
Solo haz lo que encuentres más cómodo, luego asegúrate de que todos sepan que siempre lo hagas de esa manera.
Tiendo a poner llaves de apertura en su propia línea de esta manera:
if (condition)
{
statement;
statement;
}
Entonces viendo algo como:
if (condition)
statement;
statement;
se destaca como incorrecto de inmediato. Si solo tengo una declaración, simplemente la dejo como
if (condition)
statement;
y coloque los frenos más adelante si tengo una declaración adicional para agregar. Realmente no veo ningún lugar para la confusión.
Poner el enunciado en la misma línea que la condición es un mal hábito para entrar, ya que cuando se depura, la mayoría de los depuradores cuentan todo como una sola línea. (Me doy cuenta de que en C # este no es el caso).
Yo recomendaría que te gusta Stephen y Nicholas Mancuso dijo.
Utilizar:
if(something) { DoSomething(); }
Con o sin el soporte. Tan pronto como comiences a usar una versión extraña de la declaración "if", comenzarás a ver a tus colegas mirando tu código de una manera extraña.
Normalmente uso un trazador de líneas para la validación.
Ejemplo:
if( param1 == null ) throw new ArgumentNullException("param1");
¡Estás todo INCORRECTO INCORRECTO INCORRECTO! ;-)
Afortunadamente, Vuelve a formatear todas tus locuras en mi formato aprobado personalmente, simplemente reemplazando la última llave de cada archivo.
El espacio en blanco es algo de estilo. Ya que tenemos diferentes estilos de lectura y estilos de aprendizaje, realmente no importa cómo lo hagas más. Las herramientas nos permitirán cambiar de un lado a otro. La única desventaja de esto que he notado es el costo que implica seguir los cambios en el control de la fuente. Cuando vuelvo a formatear un archivo de estilo K & R en un formato más sensato (mi opinión) y compruebo que vuelva a cambiar al control de fuente, muestra que casi todas las líneas han cambiado. Eso es un dolor. Pero muchas utilidades de diff pueden ignorar los cambios en el espacio en blanco (aunque la mayoría solo en una línea, no en líneas). Ese es un problema. Pero no es un show stopper.
C proporciona mucha libertad en los problemas de formato, por lo que tenerlos en la misma línea o en diferentes líneas es irrelevante para la compilación.
Como resultado, ese "sería malo" solo se refiere a las convenciones de codificación. Depende del contexto. Si trabajas en un equipo, es una buena idea preguntarles a los demás qué piensan y crear un estilo de formato estándar. Si no, depende de ti.
Entonces, si crees que es mejor, adelante. Si no, entonces no. Es así de simple (a menos que use un IDE que impone algunas convenciones de estilo)
Me encontré con este problema ayer mientras trabajaba en un código escrito por otra persona. El código original era:
if (something == true)
DoSomething();
y quería una impresión de depuración antes de llamar a DoSomething() . Lo que haría instintivamente
if (something == true)
print("debug message");
DoSomething();
Pero eso haría que el if aplique solo al mensaje de depuración, mientras que DoSomething() se llamaría incondicionalmente. Es por eso que prefiero tener llaves, para que la edición instintiva termine como:
if (something == true) {
print("debug message");
DoSomething();
}
Prefiero la sintaxis horrendamente indecible:
if (true == something) {
doSomething1();
}
Sí, esa es la forma en que lo hizo K & R ... y sí, vuelvo tan lejos ... y sí, esa es una buena razón para mí. Esto significa que obtengo una sintaxis común incluso cuando hago algo como esto:
if (-1 == doSomething()) {
doSomethingElse();
}
Puse las llaves, independientemente del número de líneas de código que contengan. Me ha picado la "necesidad de agregar una línea de código de prueba" y me perdí la falta de llaves varias veces.
Siempre comparo con el literal de la izquierda. Esto evita el error de "probar una tarea" (por ejemplo, si (algo = verdadero) {...}).
No hay más peligro para la portabilidad de "(algo == verdadero)" que con el conjunto de valores sobrecargado que significa "verdadero" y "falso" en una comparación booleana, pero es un tipo diferente de peligro. ¿Estás escribiendo en un idioma que considera "vacío" (y / o cero y / o NULL y / o espacio en blanco) como "verdadero" o "falso"? Prefiero una convención que sea segura para todos los casos ... porque soy flojo.