Как не тратить впустую пространство экрана при записи разреженного кода C #?

1. Я не часто вижу пространства имен, вложенные таким образом — может быть, это происходит не там, где я работаю
2. Я живу с этим. И в основном не пишите такой глубоко вложенный код. Наличие более коротких методов или методов с меньшей вложенностью, безусловно, уменьшает проблему горизонтальных пробелов, а разбиение методов на более мелкие части означает, что вы можете получить более важную информацию в заданном объеме вертикального пространства.

В дополнение к тому, что здесь говорили другие, я делаю одну вещь, чтобы уменьшить эффект, это использую шрифт с пропорциональным интервалом. Текст стал более читаемым, но не таким широким. Это также заставляет вас использовать табуляции вместо пробелов для выравнивания (именно поэтому, в первую очередь, Господь дал нам табуляции)

Лично я использую Comics Sans MS, но это действительно сводит с ума коллег....

используйте CodeRush , это значительно улучшит навигацию по вашему коду

вы получите что-то вроде этого

Ну, я купил HD-монитор ;)

Но единственный способ справиться с этим, кроме использования меньшего количества отступов, это переместить некоторый код в их собственные методы.

Я видел открытые скобки в начале строки кода, например:

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); 
                } 
            }
        } 
    } 
} 

Меньше площади, но я думаю, что это некрасиво.

Если я собираюсь что-то попробовать/поймать, я бы объединил с любым соседним, используя блоки. Точно так же я бы агрегировал пространства имен, так что что-то ближе к:

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();
                }
            }
        }
    }
}

Не думаю, что это выглядит так уж плохо ;) Однако делать более короткие функции действительно важно. В частности, хорошо, если вы можете делать такие вещи, как замена

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

на

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

Вам следует прочитать Чистый код Боба Мартина. Это помогает с этой проблемой. В данном случае SomeFunction() выполняет несколько действий. Разделите каждую вещь, которую он делает, в своем собственном методе.

 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();
                }
            }
        }
    }
}

Кроме того, не перехватывайте System.Exception; вы никогда не знаете, что может дать сбой, и вам не следует пытаться перехватывать исключения, с которыми вы не можете справиться. Пусть они пузырятся и умирают ужасно.

Я предпочитаю писать небольшие классы, короткие методы с небольшим уровнем вложенности. Мало того, что все видно на экране, так еще и код лучше!

У меня 24-дюймовый широкоэкранный монитор. Я предпочитаю "красивую печать", а не освобождение места. Сжатый, набитый вместе код трудно читать, и это вредит моему мозгу.

Я согласен с другими ответами, что я в основном живу с этим - для моей команды у нас есть либо мониторы с высоким разрешением, либо двойные мониторы (или и то, и другое), поэтому мы не разрабатываем на 800х600.

Однако следует иметь в виду, что табуляция была бы лучше, если бы вы использовали реальный интервал, так как некоторые разработчики используют 2 пробела для табуляции, некоторые 4, некоторые 6. Таким образом, хотя отформатированный код может хорошо выглядеть на IDE, на чужой может выглядеть не так хорошо. (Я видел несколько ужасных результатов от этого.)

В VS2010 есть хороший подключаемый модуль из диспетчера расширений, называемый Инструменты повышения производительности, который определяет, когда в вашем файле есть сочетание табуляции и пробелов, и позволяет вам конвертировать все на вкладки или пробелы («Исправить смешанные вкладки»). Это действительно помогает очистить ваш файл (даже если он ничего не делает!). Это здорово, если вы делитесь кодом между командами.

Позвольте мне объяснить это так. Если вы действительно столкнулись с такой глубокой вложенной конструкцией кода, как показанная выше, то проблема, вероятно, заключается не в форматировании, а в структуре вашего кода.

Вам стоит обратить внимание на это: Рефакторинг Мартина Фаулера

С помощью методов извлечения вы не только сокращаете "пустое" пространство на экране, но и значительно повышаете читабельность ;)

Еще одно решение: Alt + Shift + Enter в Visual Studio для перехода в полноэкранный режим

Оператор using очень удобен, но если код станет труднее читать, вы можете обойтись без него:

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();
            }
        }
    }
}