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

Question

Общепринятый способ форматирования кода C # выглядит следующим образом:

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

Это занимает много места на экране как по горизонтали, так и по вертикали. Я, конечно, не первый человек, который замечает. Мой вопрос: живете ли вы с этим, или вы разработали другой стиль форматирования, чтобы избежать лишних пробелов?

PS: Обратите внимание, что я еще не использовал ни одного оператора if!

Answer 1

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

Answer 2

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

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

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

Другое решение всегда: Alt + Shift + Введите в Visual Studio, чтобы перейти в полноэкранный режим

Answer 3

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

Answer 4

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

Answer 5

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

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

Answer 6

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

Answer 7

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

Answer 8

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

Answer 9

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

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

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

Answer 10

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

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

от

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