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

我不经常看到以这种方式嵌套的命名空间 - 可能它发生了，而不是我工作的地方
我和它一起生活。而且大多数都不写这种深层嵌套的代码。使用较短的方法或具有较少嵌套的方法肯定会减少水平空白问题，并且将方法分解为较小的部分意味着您可以在给定数量的垂直空间中获得更重要的信息。

Answer 2

让我这样解释一下。如果您碰巧遇到的嵌套代码构造与上面显示的那样深，那么问题可能不是格式化而是代码结构。

您应该考虑一下这个： Refactoring by Martin Fowler

通过 extracting methods ，您不仅可以改善“浪费”的屏幕空间，还可以显着提高可读性;）

另一种解决方案始终是： Alt + Shift + 在Visual Studio中输入以进入全屏模式

Answer 3

我买了一台高清显示器;）

但除了使用更少的缩进之外，处理它的唯一方法是将一些代码移动到他们自己的方法中。

Answer 4

工具＆gt;选项＆gt;文本编辑器＆gt;所有语言＆gt;标签＆gt;缩进尺寸＆gt; 1
不是一个很好的解决方案......：P

Answer 5

你应该阅读Bob Martin的Clean Code。它有助于解决这个问题。在这种情况下，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 6

我倾向于编写小类，具有较小嵌套级别的简短方法。您不仅可以在屏幕上看到所有内容，而且代码也更好！

Answer 7

我有一台24英寸宽屏显示器。我非常喜欢“漂亮打印”而不是回收空间。压缩，挤压在一起的代码很难阅读并伤害我的大脑。

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

Answer 9

不要认为它看起来那么糟糕;）然而，缩短功能确实是一个重点。特别是，如果你可以做替换

这样的事情，那就太好了

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

通过

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

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

较少的房地产，但我认为它很难看。

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

Answer 12

我同意其他基本上与之相关的答案 - 对于我的团队，我们要么拥有高分辨率显示器，要么配备双显示器（或两者兼有），所以它不像我们正在开发800x600。

但有一点要记住，如果你使用实际间距，你的标签会更好，因为一些开发人员使用2个空格作为标签，大约4个，大约6个。所以虽然格式化的代码在一个开发人员看来可能很好IDE，它可能在另一个上看起来不那么好。（我从中看到了一些可怕的结果。）

VS2010有一个来自Extensions Manager的一个很好的插件，名为Productivity Tools，可以检测文件中混合使用标签和空格，并允许您将所有内容转换为标签或空格（“修复混合标签”）。它真的有助于清理你的文件（即使它看起来不像它做任何事情！）。如果您在团队之间共享代码，那就太棒了。

Answer 13

使用 CodeRush ，它会更好地导航你的代码

你会得到这样的东西

Answer 14

除了其他人在这里所说的，我做的一件事就是减少效果，就是使用比例间距的字体。文本更具可读性，但不是那么宽。它还会强迫你在空格上使用标签进行对齐（这当然是为什么好主在一开始就给了我们标签）

我个人使用Comics Sans MS，但这确实让同事疯狂......

Answer 15

一些一般性的想法：

将这些名称空间块合并为一个。
如果可以的话，将using个语句集中到一个地方。
如果你不是狂热的“即使单个陈述需要附上{} s！”，你也可以摆脱using和{{之间的括号1}}阻止。
考虑是否真的需要嵌套的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的语句，如另一个答案所示。）

如何避免浪费屏幕空间编写稀疏的C＃代码？

15 个答案: