C# convention

[John Salerno]

I just realized that the C# convention for uses braces is to put the
opening brace immediately after the first line that defines the block
(except for class declarations) like this:

if (something) {
stuff
}

Why is that? Do a lot of people do this? It seems like putting braces on
separate lines is much nicer and easier to read. In the book I'm
reading, it says it's important that the closing brace line up with the
first line (like above), I guess for readability, but how common is
this? It doesn't seem as readable as this:

if (something)
{
stuff
}

[Bruce Wood]

Oh dear. The curly brace debate. There's a special punishment reserved
for people who resurrect this one. ;-)

I used to be passionate about this university. I knew others who were
equally passionate about using the other style. There was even a third
option, which looked like this:

if (something)
{ stuff
...
}

Twenty years on, I have a very simply rule: use whatever style the IDE
gives you for free. In cases like Visual Studio, where the IDE allows
you to choose, everybody pick one common style and stick to it.

Really! "Readable" is in the eyes of the beholder, and the only
less-readable code is code that's formatted in an unfamiliar way, which
forces you to do extra mental work to read it. If everyone in your
company is accustomed to seeing braces lined up vertically, then use
that style. If everyone is used to saving vertical space by putting the
opening brace at the end of the line, then use that style.

If you're a consultant, then adapt to the style of your client. That's
why they pay you the big bucks, after all. :-)

At every place I've worked in the past 15 years (since I lost curly
brace religion), the only thing I've wanted in this regard was an
auto-formatter to run everyone's code through (including mine), so that
it all looked the same, and no, I didn't care which convention it used,
so long as there was just one convention.

My 2¢ worth... let the games begin! :-)

[Jon Skeet [C# MVP]]

John Salerno <jo******@NOSPA Mgmail.com> wrote:

I just realized that the C# convention for uses braces is to put the
opening brace immediately after the first line that defines the block
(except for class declarations) like this:

if (something) {
stuff
}
Which convention do you mean? The MS "Design Guidelines for Class
Library Developers" seems to use the bracing you've used below, in the
few examples I looked at just now.
Why is that? Do a lot of people do this? It seems like putting braces on
separate lines is much nicer and easier to read. In the book I'm
reading, it says it's important that the closing brace line up with the
first line (like above), I guess for readability, but how common is
this? It doesn't seem as readable as this:

if (something)
{
stuff
}

In my experience, this is far more common than the former (K&R)
bracing.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[John Salerno]

Bruce Wood wrote:

Oh dear. The curly brace debate. There's a special punishment reserved
for people who resurrect this one. ;-) My 2¢ worth... let the games begin! :-)

Oh no, what did I do!? :)

[John Salerno]

Jon Skeet [C# MVP] wrote:

Which convention do you mean? The MS "Design Guidelines for Class
Library Developers" seems to use the bracing you've used below, in the
few examples I looked at just now.

Yeah, actually I thought the MS guidelines used my second example too,
and maybe I've seen some samples of it. But the book I'm reading
(Beginning C# Objects) says that the C# convention is to put the opening
brace on the same line as the code, and since I was unsure about this I
went to the FCL and checked a few of the samples there (I just went to
some random Forms classes, for example) and those use the first example.

[Jon Skeet [C# MVP]]

John Salerno <jo******@NOSPA Mgmail.com> wrote:

Which convention do you mean? The MS "Design Guidelines for Class
Library Developers" seems to use the bracing you've used below, in the
few examples I looked at just now.
Yeah, actually I thought the MS guidelines used my second example too,
and maybe I've seen some samples of it. But the book I'm reading
(Beginning C# Objects) says that the C# convention is to put the opening
brace on the same line as the code,

Without specifying *which* C# convention he means, the author's
statement is pretty much meaningless.
and since I was unsure about this I
went to the FCL and checked a few of the samples there (I just went to
some random Forms classes, for example) and those use the first example.

By the FCL, do you mean the Rotor implementation? If so, from what I've
seen there isn't a consistent convention (for pretty much anything!).

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Helge Jensen]

Bruce Wood wrote:

Oh dear. The curly brace debate. There's a special punishment reserved
for people who resurrect this one. ;-)

big-endian braces are better than little endian, the nazi's says so.

(that should help the fire get started ;)

--
Helge Jensen
mailto:he****** ****@slog.dk
sip:he********* *@slog.dk
-=> Sebastian cover-music: http://ungdomshus.nu <=-

[Bruce Wood]

> In the book I'm reading, it says it's important that the closing brace line up with the first line (like above), I guess for readability.

"Important" ? Oh, absolutely. The author is absoluately correct: your
code will run 20% slower if you do not follow this convention. ;-)

If you go into Visual Studio's Tools -> Options menu, and choose C# ->
Formatting, you'll see that the first option is "Leave open braces on
same line as construct". It is, by default, turned off, leading to the
second kind of formatting: open braces on a separate line, directly
above closing braces.

If it's so "important" to leave the brace on the same line as the
construct, why does VS turn this off by default? The author's statement
is simply silly.

This is not to say that there is nothing to recommend the
brace-at-the-end convention. The common justification I've heard for it
is that it saves a line of screen real estate that you can use to show
more useful things, like more code. People who like the
open-brace-on-same-line convention complain that putting the brace on
its own line spreads the code out too much and leads to more scrolling
about in order to read things.

Defenders of the open-brace-above-closed-brace convention typically
complain that the other convention leads to densely packed and
difficult to read code.

The third convention that I posted was a later attempt to make both
camps happy. Apparently, it failed.

As I said, I don't care any more. If the IDE ships with "Leave open
braces on same line as construct" turned off, then I just leave it off.
I have better things to worry about.

The only people who piss me off are guys who insist on using the "other
convention" (whatever that is in their particular workplace) because
it's "far superior," and insist on going through their colleague's
code, reformatting all of the curly braces. I get my revenge by
assigning them a heavier workload: obviously they don't have enough to
do. :-)

[Beetlejuice]

John Salerno wrote:

I just realized that the C# convention for uses braces is to put the
opening brace immediately after the first line that defines the block
(except for class declarations) like this:

if (something) {
stuff
}

Why is that? Do a lot of people do this? It seems like putting braces on
separate lines is much nicer and easier to read. In the book I'm
reading, it says it's important that the closing brace line up with the
first line (like above), I guess for readability, but how common is
this? It doesn't seem as readable as this:

if (something)
{
stuff
}

I use the first style you describe. Personally I really don't care what
style any code I come across uses, I just CTRL+A, CTRL+F (select all,
format selection) the whole lot of it and go on with my way. If I'm
working on someone else's code, i adopt their style. If I write my own
code (the usual case) i use K&R style, where the opening curly is on the
same line as the condition statement, and the elses and catches are all
cuddled.

What really annoys me to no end is websites that give examples of code
like this: (this is the most annoying style i can imagine)

if (condition)
{
expression;
}
else if (condition)
{
if (condition)
{
if (condition)
{
try
{
expression
}
catch
{
}
}
}

i'm to the point now where just looking at working code gives me all the
tips i need (usually) to make my code work, so copying the example code
and putting it into a new project just so i can reformat it is a lot of
extra work that i don't want to bother with.

so, to answer your question, i use the style i example below, and i
recommend that every new programmer uses this style because its the way
i like it and if everyone did things my way there would be no war or
hunger or any other nasty stuff. It looks a little dense but I guess I
like it that way:

if (condition) {
// that's three spaces
} else if (condition) {
try {
Console.WriteLi ne(6/0); // div by 0
} catch (Exception) {
Console.WriteLi ne("you knew that would happen.");
}
}

[Beetlejuice]

John Salerno wrote:

[snip]
Rotor?

http://www.microsoft.com/downloads/d...displaylang=en

Microsoft's Shared Source C# compiler. MS says that it compiles out of
the box on FreeBSD, Windows XP, and MacOS X 10.2.

From what I've read in various places, it is a .NET 1.1 compatible
implementation, and that the garbage collector isn't as efficient as
what is available in .NET.

I've not dug very deeply into this, so I may be mistaken on the points
above.

If you're looking for a Free implementation of a C# compiler, have a
look at http://mono-project.com/ - its open sourced and runs very well
from what I understand.