¿Cómo evitar el desperdicio de espacio en la pantalla al escribir código C# escaso?

Question

La forma más comúnmente aceptada para dar formato a código C# parece ser como sigue:

namespace SomeNamespace 
{ 
    namespace SomeSubNamespace 
    { 
     class SomeClass 
     { 
      void SomeFunction() 
      { 
       using (var someFile = new StreamWriter(somePath)) 
       { 
        try 
        { 
         lock(someCriticalSection) 
         { 
          using (var someDisposableThing1 = new DisposableThing()) 
          { 
           DoSomething();        
           using (var someDisposableThing2 = new DisposableThing()) 
           { 
            lock(someOtherCriticalSection) 
            { 
             DoSomethingMore(); 
            } 
           } 
          } 
         } 
        } 
        catch(Exception e) 
        { 
         Log(e); 
        } 
      } 
     } 
    } 
} 

Esto desperdicia una gran cantidad de espacio en la pantalla, tanto horizontal como verticalmente. Seguramente no soy la primera persona que nota. Mi pregunta es: ¿Vives con ella o has desarrollado un estilo de formato diferente para evitar un exceso de espacio en blanco?

PD: ¡Tenga en cuenta que ni siquiera utilicé una única declaración if todavía!

Answer 1

tiendo a escribir pequeñas clases, métodos cortas de pequeño nivel de anidamiento. ¡No solo puedes ver todo en tu pantalla, también el código es mejor!

Answer 2

Tengo un 24" monitor de pantalla ancha. Yo preferiría en gran medida 'de impresión legible' sobre la recuperación del espacio. Condensada, código-abarrotado juntos es difícil de leer y me duele el cerebro.

Answer 3

1. no lo hago a menudo ver espacios de nombres anidados de esa manera - tal vez sucede, no donde trabajo
2. que vivo con ella y en su mayoría no escribir dicho código profundamente imbricada que presenta los métodos más cortos, o métodos con menos de anidación sin duda reduce el problema de espacio en blanco horizontal.. y tener métodos rotos en pedazos más pequeños significa que puede obtener la información más importante en una determinada cantidad de espacio vertical.

Answer 4

Bueno He comprado un monitor HD;)

Pero la única manera de tratar con él, aparte de usar menos sangría sería mover un código en sus propios métodos.

Answer 5

Si voy a tratar/catch algo, me gustaría combinar con cualquier utilizando bloques adyacentes. Del mismo modo, me gustaría agregar espacios de nombres, de manera algo más cercano a:

namespace SomeNamespace.SomeSubNamespace 
{ 
    class SomeClass 
    { 
     void SomeFunction() 
     { 
      StreamWriter someFile; 
      try 
      { 
       someFile = new StreamWriter(somePath); 

       lock(someCriticalSection) 
       { 
        using (var someDisposableThing1 = new DisposableThing()) 
        { 
         DoSomething();        
         using (var someDisposableThing2 = new DisposableThing()) 
         { 
          lock(someOtherCriticalSection) 
          { 
           DoSomethingMore(); 
          } 
         } 
        } 
       } 
      } 
      catch(Exception e) 
      { 
       Log(e); 
      } 
      finally 
      { 
       if(someFile != null) 
       { 
        someFile.Dispose(); 
       } 
      } 
     } 
    } 
} 

Answer 6

no creo que se ve tan mal;) haciendo funciones más cortas sin embargo sí que es un punto. En particular, es bueno si se puede hacer cosas como la sustitución de

if (condition) 
{ 
    // bla 
} 
else 
{ 
    // blub 
} 

por

void someFunction() 
{ 
    if (condition) 
    { 
    // bla 
    return 
    } 
    // blub 
} 

Answer 7

Me explico como este. Si realmente encuentras un constructo de código anidado tan profundo como el que muestras arriba, entonces el problema probablemente no sea el formato, sino la estructura de tu código.

Usted debe considerar tomar un vistazo a esto: Refactoring by Martin Fowler

Por extracting methods a mejorar no sólo el "desperdiciado" espacio en la pantalla, pero se aumenta drásticamente la legibilidad también;)

Otra solución es siempre: Alt + Shift + Ingrese en Visual Studio para pasar al modo de pantalla completa

Answer 8

Estoy de acuerdo con las otras respuestas en las que básicamente vivo; para mi equipo, o bien tenemos monitores de alta resolución o monitores duales (o ambos), así que no es como si estuviéramos desarrollando en 800x600.

Pero una cosa a tener en cuenta es que su tabulación sería mejor si utilizó el espaciado real, ya que algunos desarrolladores usan 2 espacios para una pestaña, algunos 4, algunos 6. Así que mientras que el código formateado puede verse bien en uno IDE del desarrollador, puede no verse tan bien en el otro. (He visto algunos resultados horribles de eso.)

VS2010 tiene un buen complemento del Administrador de Extensiones llamado Productivity Tools que detecta cuando tienes una combinación de pestañas y espacios en tu archivo y te permite convertir todo a pestañas o espacios ("Fix Mixed Tabs"). Realmente ayuda a limpiar su archivo (incluso si no parece que haga nada). Es genial si compartes código entre equipos.

Answer 9

Herramientas> Opciones> Editor de texto> Todos los Idiomas> aquí> Tamaño sangría> 1
No una gran solución ...: P

Answer 10

uso CodeRush, que va a hacer la navegación a través de tu código mucho mejor

obtendrá algo como esto

Answer 11

que he visto soportes abiertos en la línea de inicio de un bloque de código como en:

namespace SomeNamespace { 
    class SomeClass { 
     void SomeFunction() { 
      using (var someFile = new StreamWriter(somePath)) { 
       try { 
        lock(someCriticalSection) { 
         using (var someDisposableThing1 = new DisposableThing()) { 
          DoSomething();        
         } 
        } 
       } catch(Exception e) { 
        Log(e); 
       } 
      } 
     } 
    } 
} 

Menos bienes raíces, pero creo que es feo.

Answer 12

Debería leer Bob Martin's Clean Code. Ayuda con este problema En este caso, SomeFunction() hace más de una cosa. Dividir cada cosa que hace en su propio método.

namespace SomeNamespace.SomeSubNamespace 
{ 
    class SomeClass 
    { 
     void WriteToFile() 
     { 
      using (var someFile = new StreamWriter(somePath)) 
      { 
       lock(someCriticalSection) 
       { 
        ExecuteCriticalSection(); 
       } 
      } 
     } 
     void ExecuteCriticalSection() 
     { 
      using (var someDisposableThing1 = new DisposableThing()) 
      { 
      DoSomething(); 
      ExecuteFinalCriticalSection(); 
      } 
     } 

     void ExecuteFinalCriticalSection() 
     { 
      using (var someDisposableThing2 = new DisposableThing()) 
      { 
      lock(someOtherCriticalSection) 
       { 
       DoSomethingMore(); 
       } 
      } 
     } 
    } 
} 

Además, no coger un System.Exception; nunca se sabe lo que va a fallar, y no se debe tratar de detectar excepciones que no se pueden manejar. Déjalos burbujear y morir horriblemente.

Answer 13

Además de lo que otros han dicho aquí, una de las cosas que hago para disminuir el efecto es utilizar una fuente de espaciado proporcional. El texto es más legible, pero no tan ancho. También te obliga a usar pestañas sobre los espacios para la alineación (que es, por supuesto, por qué el buen Señor nos dio pestañas en primer lugar)

Yo personalmente uso Comics Sans MS, pero eso enloquece a tus compañeros de trabajo ....

Answer 14

La instrucción using es muy práctico, pero si se convierte en código más difícil de leer se puede prescindir de él:

namespace SomeNamespace.SomeSubNamespace 
{ 
    class SomeClass 
    { 
     void SomeFunction() 
     { 
      StreamWriter someFile = new StreamWriter(somePath); 
      DisposableThing someDisposableThing1 = null; 
      DisposableThing someDisposableThing2 = null; 

      try 
      { 
       lock (someCriticalSection) 
       { 
        someDisposableThing1 = new DisposableThing(); 
        DoSomething(); 
        someDisposableThing2 = new DisposableThing(); 
        lock (someOtherCriticalSection) 
        { 
         DoSomethingMore(); 
        } 
       } 
      } 
      catch (Exception e) 
      { 
       Log(e); 
      } 
      finally 
      { 
       // requires SafeDispose extension method 
       someFile.SafeDispose(); 
       someDisposableThing1.SafeDispose(); 
       someDisposableThing2.SafeDispose(); 
      } 
     } 
    } 
} 

Answer 15

Algunas ideas generales:

• combinar esos bloques de espacio de nombres en una sola.
• Reúna las declaraciones using en un solo lugar, si puede.
• Si no es un fanático "Incluso las declaraciones individuales deben incluir {} s!", podría deshacerse de los corchetes entre los bloques using y try..catch.
• Piensa si realmente se requieren lock s anidados, o si el lock más externo será suficiente.

Estos podría resultado en el siguiente código (tener en cuenta que el significado de su código de ejemplo hipotético no puede conservarse exactamente):

namespace SomeNamespace.SomeSubNamespace 
{ 
    class SomeClass 
    { 
     void SomeFunction() 
     { 
      using (var someFile = new StreamWriter(somePath)) 
      try 
      { 
       lock(someCriticalSection) 
       { 
        using (var someDisposableThing1 = new DisposableThing()) 
        using (var someDisposableThing2 = new DisposableThing()) 
        { 
         DoSomething();        
         DoSomethingMore(); 
        } 
       } 
      } 
      catch(Exception e) 
      { 
       Log(e); 
      } 
     } 
    } 
} 

(incluso se podría mover los dos using s a la otra instrucción using fuera del lock, si su código lo permite. Puede reemplazar las declaraciones using con llamadas explícitas al Dispose en un bloque finally, como se sugiere en otra respuesta)