Как избежать траты пространства экрана, написания разреженного кода на С#?

Ответ 1

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

Ответ 2

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

Вы должны рассмотреть возможность взглянуть на это: Рефакторинг Мартина Фаулера

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

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

Ответ 3

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

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

Ответ 4

Инструменты > Параметры > Текстовый редактоp > Все языки > Вкладки > Размер отступa > 1
Не отличное решение...: P

Ответ 5

Вы должны прочитать Bob Martin Очистить код. Это помогает с этой проблемой. В этом случае 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; вы никогда не знаете, что произойдет, и вы не должны пытаться поймать исключения, с которыми вы не справитесь. Пусть они пузырятся и умирают ужасно.

Ответ 6

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

Ответ 7

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

Ответ 8

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

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

Ответ 9

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

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

по

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

Ответ 10

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

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

Меньше недвижимости, но я считаю ее уродливой.

Ответ 11

Оператор 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();
            }
        }
    }
}

Ответ 12

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

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

VS2010 имеет хороший плагин из Диспетчера расширений, называемый инструментами производительности, который обнаруживает, когда у вас есть сочетание вкладок и пробелов в вашем файле, и позволяет конвертировать все в вкладки или пробелы ( "Fix Mixed Tabs" ). Это действительно помогает очистить файл (даже если это не похоже на что-то!). Это здорово, если вы делитесь кодами между командами.

Ответ 13

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

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

Ответ 14

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

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

Ответ 15

Некоторые общие идеи:

• Объедините эти блоки пространства имен в один.
• Соберите инструкции using в одном месте, если сможете.
• Если вы не фанатик "Даже одиночные утверждения требуют включения {} s!", вы можете избавиться от скобок между блоками using и try..catch.
• Подумайте о том, действительно ли вложенные lock или если внешний lock будет достаточным.

Это может привести к следующему коду (обратите внимание, что значение вашего гипотетического кода примера не может быть точно сохранено):

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

(Вы могли бы даже переместить два using в другой оператор using вне lock, если бы ваш код разрешил его. Вы могли бы заменить операторы using явными вызовами на Dispose в finally, как предложено в другом ответе.)