Stylecop 设置在什么时候不再有用并开始变得烦人?
我在一个团队工作,我们在 StyleCop 中使用广泛的规则集,我想知道对于这样的工具不再有用并且开始变得烦人的一般观点有什么想法。我们还使用 GhostDoc,因此代码中充满了 XML 注释,这使得代码更难以阅读和审查。我对 XML 注释没有任何问题,并且发现它们在某些地方非常有用,但是每个字段和属性真的需要它们吗?
我们有一个令人钦佩的目标“每个项目在构建时必须有 0 个警告”,但这个目标肯定需要违反合理的 StyleCop 规则集,否则宝贵的时间会浪费在“修复”StyleCop 警告的原因上。
对此有何想法?
编辑 我现在实际上想知道像 stylecop 这样的工具到底有什么论据?为什么不放弃它,让合理的编码标准和良好的代码审查来处理剩下的事情呢?尤其是在一个优秀的有能力的团队中?当然,获得 0 个警告的任务实际上会增加价值,因为所有警告都是相关的。
我认为 GhostDoc 的唯一优点是它可以为您从头开始编写 XML 注释节省宝贵的几秒钟时间。我认为您不应该在不编辑的情况下接受生成的评论 - 这可能会适得其反。
这是由 GhostDoc 生成的 xml 注释满足的 Stylecop 规则(SA1642:ConstructorSummaryDocumentationMustBeginWithStandardText)的组合 - 是否在一天结束时添加任何值?
/// <summary>
/// Initializes a new instance of the <see cref="SomeCustomType"/> class.
/// </summary>
/// <param name="someParameter">The someParameter.</param>
public SomeCustomType(string someParameter)
{
}
I work in a team where we use extensive ruleset in StyleCop and I am wondering what are the thoughts on the general point where such a tool stops being useful and starts becomes annoying. We also use GhostDoc so code is riddled with XML comments which make the code much harder to read and thus review. I have no problem with XML comments and find them very useful in places but are they really needed on every field and property?
We have the admirable goal of "each project must have 0 Warnings when built" but surely this goal needs to be against a reasonable StyleCop ruleset otherwise valuable time is wasted in "fixing" the cause of the StyleCop warnings.
What are the thoughts on this?
EDIT
I'm now actually wondering what is the argument for a tool like stylecop AT ALL? Why not ditch it and let sensible coding standards and good code reviews take care of the rest? Especially in a good competent team? Surely then the task of getting 0 Warnings would actually add value as all Warnings would be relevant.
I think the only advantage of GhostDoc is it saves you a vital few seconds in writing an XML comment from scratch. I don't think you should accept the generated comment without editing it - which is counter-productive maybe.
Here's a combination of a Stylecop rule (SA1642: ConstructorSummaryDocumentationMustBeginWithStandardText) being met by GhostDoc generated xml comment - does either add any value at the end of the day?
/// <summary>
/// Initializes a new instance of the <see cref="SomeCustomType"/> class.
/// </summary>
/// <param name="someParameter">The someParameter.</param>
public SomeCustomType(string someParameter)
{
}
如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱,如果其他用户或者作者回复了您的评论,将不能在第一时间通知您!
发布评论
评论(6)
我认为这更像是一种咆哮而不是一个问题,但我同意你的观点:
虽然显然应该有源代码格式的指导方针,但过度规定的牢不可破的规则会导致令人不快的极端情况。在所有情况下严格遵守规则可能会生成难以阅读的混乱或过度包装的代码。
编码是一种不同的写作方式,因此奥威尔的奖励规则——“打破任何这些规则,不要说任何彻头彻尾的野蛮行为”——也需要适用于编码风格指南。
我怀疑在一个由能够设置和理解样式指南的有能力的程序员组成的团队中,自动执行样式是否是一个好主意。自动 lint 对于发现意外错误很有用,但如果应用于代码格式化的高度规范性法律,它们就无法考虑奥威尔规则。有了强大的规则集,这可能会迫使您在可维护性的幌子下编写难以维护的代码。
如果你的团队中有能力较差的编码员,他们的输出是混乱的,除非强制风格化,那么强制执行可能是一个好主意。 (但是你可能会遇到更大的问题!)
我以前没有见过 GhostDoc,但实际上我有点震惊。
他们自己首页上的这个例子
几乎是坏评论的典型例子,对它所记录的代码添加了绝对零的洞察力。这绝对比没有评论文档更糟糕。
Javadoc 遵循的所有源文档内模式有时都有点可疑,因为它们将源代码与通常针对最终用户(与阅读代码的受众完全不同的受众)的材料混在一起。但这绝对是坑。我无法想象谁认为这是个好主意。
This is more of a rant than a question, I think, but I agree with you that:
Whilst there should obviously be guidelines for source code formatting, over-prescriptive unbreakable rules lead to unpleasant corner cases. Sticking strictly to the rules in all cases can generate unreadably messy or over-wrapped code.
Coding is a variety of writing, and as such Orwell's Bonus Rule—“Break any of these rules sooner than saying anything outright barbarous”—needs to apply to coding style guides too.
I am sceptical that automated style enforcement is a good idea, in a team of competent programmers who can set and understand style guides. Automated lints are useful for catching accidental mistakes, but if applied with highly prescriptive laws for code formatting they cannot take account of Orwell's rule. With a strong ruleset, this may force you to write less-maintainable code under the guise of maintainability.
If you've got less-competent coders in your team, whose output is a jumble unless forced into style, then enforcement might be a good idea. (But then you've probably got bigger problems!)
I hadn't seen GhostDoc before, but I'm actually a little bit shocked.
The very example on their own front page:
is almost the canonical example of a Bad Comment, adding absolutely zero insight into the code it documents. This is absolutely worse than no comment-doc.
All the in-source-doc schemas that followed Javadoc are a little bit suspect at times, since they clutter the source code with material that's often aimed at end-users—a quite different audience to those reading the code. But this is the absolute pits. I can't imagine who thought this was a good idea.
StyleCop 是一个工具。它不应该是完美的开箱即用,也不应该满足每个人的需求。
我个人说“是的,这很重要”——因为当您管理一个开发团队时,StyleCop 可以帮助您确保遵守您的编码指南。这正是其目的:以自动化、可测量、一致的方式评估编码标准。如果您不想在构建过程中执行此操作,那么您是对的 - 这是浪费时间。
您自己说过:零警告目标“需要违反合理的 StyleCop 规则集”。运行任何配置不符合您需求的工具都是没有意义的。如果一条规则对你来说“烦人”,那么就将其关闭——但对其他人来说,它可能至关重要。
至于你的“是否增加价值”的问题:是的。人们低估了一致性的价值。如果所有构造函数都具有相同的注释风格,如果项目中属性的所有智能感知都具有相同的结构,那么需要处理的心理障碍(无论多小)就少了一个。借助自动化工具,几乎可以实现零工作量。有什么可抱怨的?
StyleCop is a tool. It's not supposed to be perfect out of the box, and it's not supposed to meet everyone's needs.
Personally I say "Yes, it's important" - because when you're running a team of devs, StyleCop helps you ensure that your coding guidelines are being adhered to. That's exactly its purpose: to evaluate coding standards in an automated, measurable, consistent manner. If you don't want the ability to do that in your build process then you're right - it's a waste of time.
You say it yourself: the zero-warnings goal "needs to be against a reasonable StyleCop ruleset." There's no point running any tool with a configuration that doesn't match your needs. If a rule is "annoying" for you then turn it off - but for someone else it might be vitally important.
As to your "does either add value" question: yes. People underestimate the value of consistency. If all of your constructors have the same style of comment, if all the Intellisense for properties in your project have the same structure, it's one less mental hurdle (no matter how small) to deal with. And with tools that automate it, it's at almost zero effort. What's to complain about?
当围绕规则进行编码所花费的时间比通过减少维护所获得的时间要多时。
如您所知,修复错误比编写错误要花费更多的时间,因此在达到阈值之前,您仍然可以做大量额外的工作来使代码更加健壮和可维护。
When it takes more time to code around the rule, than what you ever could get back by reduced maintainence.
As you know, fixing a bug takes a lot more time than writing it, so you can still do quite a lot extra work to make the code more robust and maintainable before you reach the threshold.
代码写得好、可读/可维护是至关重要的,但我们使用 Visual Studio 和 Resharper 的自动代码格式化助手来处理我们的代码,并使用 AtomineerUtils 将 XML 文档注释保持在严格定义和整洁的格式中。
因此,主要的 StyleCop 规则是无关紧要的,因为我们的代码始终“默认”遵守重要规则。较小的 StyleCop 规则对于日常使用来说往往过于严格。 (大多数这些规则只能对代码的质量或可读性做出微小的(如果有的话)改进,因此我们发现遵守它们的成本是不可接受的。我们允许程序员有一点“表达自由”——只要他们的代码团队中的其他人很容易阅读,我们不介意编码风格的微小变化)。因此,在评估 StyleCop 后,我无法找到任何现实世界的好处。
相比之下,我们发现 FXCop 非常有用,因为它突出显示的问题不仅仅是小的可读性问题 - 它会不时发现严重的错误和性能问题。
It's vitally important that code is well written and readable/maintainable, but we use Visual Studio and Resharper's automatic code-formatting helpers for our code, and AtomineerUtils to keep XML documentation comments in a strictly defined and tidy format.
As a result, the main StyleCop rules are irrelevant, as our code always adheres to the important rules "by default". The lesser StyleCop rules tend to be rather too strict for everyday use. (Most of these rules only make tiny, if any, improvements to the quality or readability of code, so we find the cost of adhering to them unacceptable. We allow our programmers a bit of "freedom of expression" - as long as their code is easily readable by others in the team, we don't mind minor variations in coding style). So after evaluating StyleCop I was unable to find any real world benefit.
In contrast we find FXCop very useful, because the problems that it highlights are more than just about minor readability issues - it picks up serious bugs and performance issues from time to time.
你的问题有几点引起了我的注意,所以我想在之前的回答的基础上补充一些想法。
有些字段和属性对每个人来说都是显而易见的,不需要解释。例如,如果类
Cooperative
具有属性X
、Y
和Z
,则无需解释的评论。但对于像 StyleCop 这样的工具,在第一次发现源代码时,工具无法区分明显的属性和可能难以理解的属性。所以不,并不是所有地方都需要注释,但我们要么对每个字段和属性强制注释,要么禁用该规则并让开发人员决定。
不知何故。有些工具像其他方法一样显示构造函数,并且您无法在视觉上区分两者(除非您记住类的名称)。另一方面,XML 注释非常清晰,因此很容易理解这是一个构造函数。
顺便问一下,你还想在这里写什么?
还有别的事吗?没有构造函数的标准将导致阅读代码和理解方法是视图中的构造函数(两者以相同的方式显示)变得困难。
完全没有评论吗?它可以是一个解决方案,因为这样的注释可以很容易地从类的名称生成。但这会让事情变得更加复杂(为什么要自动生成对构造函数而不是其他方法的注释?)。另外,如果您没有提供此构造函数的描述,那么有人怎么知道
someParameter
是什么?最后,回答你的问题,没有人可以说每条 StyleCop 规则在每种情况下都总是有用。但请记住,这里的废话是“每个项目构建时必须有 0 个警告”的目标,而不是 StyleCop 本身。如果您是一位经验丰富的开发人员并且编写了干净的代码,那么没有理由不关闭某些 StyleCop 规则,至少如果您很好地理解它们的含义、它们为什么在这里以及不遵守规则会产生什么后果。
在我们公司,我们有一项政策,要求每个项目都使用 StyleCop,如果一个小项目有数百个警告,那么就有问题了。同时,我经常遇到这样的情况:我在整个类上禁用了一些 StyleCop 规则,只是因为执行它们会浪费时间,而且不会给任何人带来任何东西。另一方面,当我的同事禁用 FxCop/StyleCop 只是以便能够用法语编写类、方法和属性的名称时,我一点也不感激(我在一家法国公司,也适用于说英语的开发人员),所以我想说,对于某些人来说,这两种工具都必须每次都启用,而无法禁用它们。
There are a few points of your question that attracted my attention, so I would like to add some thoughts to the previous answers.
Some fields and properties are so obvious to everyone, that they don't need an explanation. For example, if a class
Coordinate
has the propertiesX
,Y
andZ
, there is nothing to explain in the comments.But when it comes to a tool like StyleCop, a tool cannot make a difference between an obvious property and a property which has chances to be difficult to understand when discovering the source code for the first time. So no, comments are not needed everywhere, but we either enforce comments on every field and property, or we disable the rule and let the developer decide.
Somehow. Some tools display constructors just like other methods, and you can't make any difference visually between the two (unless you keep in mind the name of the class). The XML comment, on the other hand, is so clear that it makes it very easy to understand that this is a constructor.
By the way, what else would you write here?
Something else? Not having a standard for the constructors will make it difficult to read code and to understand that a method is a constructor in views where both are displayed in the same way.
No comment at all? It can be a solution, since such comment can be easily generated from the name of the class. But it will make things more complicate (why auto-generating a comment on constructors and not on other methods?). Also, if you provide no description for this constructor, how can somebody know what is
someParameter
?Finally, to answer your question, nobody can say that every StyleCop rule is always useful in every case. But remember that the nonsense here is the goal of "each project must have 0 Warnings when built", not the StyleCop itself. If you're an experienced developer and write clean code, there is no reason to not turn off some StyleCop rules, at least if you understand well what they mean, why they are here and what will be the consequence to not follow the rule.
In our company, we have a policy to use StyleCop for every project and if there are hundreds of warnings on a tiny project, well, there is a problem. At the same time, I often had situations where I disabled a few StyleCop rules on whole classes, just because it will waste time to enforce them, and it does not bring anything to anyone. On the other hand, I didn't appreciate at all when my colleague disabled FxCop/StyleCop just to be able to write names of classes, methods and properties in French (I'm in a French company which also works with English-spoken developers), so I would say that for some people, both tools must be enabled every time, with no ability to disable them.
拥有一个每个人都使用的固定样式是很有用的,并且对于新代码StyleCop 将强制执行这一点以使每个人受益。
但是,当将 StyleCop 添加到用不同风格编写的现有项目时,您将遇到数百、数千或数万次违反内容的情况。本质上是任意规则,例如:
if
后面必须跟一个空格this
仅仅为了遵守这样的规则而编辑数千个现有文件和数十万行代码是没有意义的。
如果答案是“让 StyleCop 闭嘴”——老实说——有不止一种方法可以做到这一点。
您的目标应该是消除不代表错误的警告,以便您可以看到 - 然后修复 - 更有问题的警告,这可能会起作用。存在 1500 个有关单行注释格式的警告是您可以摆脱的障碍。
因此,在遗留代码库中:
It's useful to have a set style that everybody uses, and for new code StyleCop will enforce this to everyone's benefit.
But when adding StyleCop to an existing project which was written with a different style, you will get hundreds, or thousands, or tens of thousands of violations of what are, essentially, arbitrary rules such as:
if
must be followed by a spacethis
It simply makes no sense to edit thousands of existing files with hundreds of thousands of lines of code just to comply with such rules.
If the answer is "to shut up StyleCop" - and be honest - there is more than one way of doing that.
Your goal should be to eliminate warnings which don't represent bugs, so that you can see - and then fix - the more problematic warnings, which may do. The presence of 1500 warnings about the formatting of single-line comments is an obstacle you can do without.
Therefore, in a legacy codebase: