Naming conventions in For... each

[Robert Jacobson]

Hello all,

If I have a class called "Foo," is there a preferred naming convention for
iterating through each Foo instance in a collection of Foos? I've seen
several different variations, even in the MSDN documentation:
#1:
For each Foo as Foo in Foos
...
Next Foo

This variation is direct, but a bit ambiguous since it's using the same name
for the Foo class and the Foo instance. (I know that the "Foo" in "Next
Foo" is optional -- I'm just including it for clarity.)
#2:
For each MyFoo [or aFoo, TheFoo, etc.] as Foo in Foos
...
Next MyFoo

This variation eliminates the ambiguity by adding a prefix to the instance
name. However, it seems a bit too "cutesy" for me.
#3:
For each f as Foo
...
Next f

This appears to be the C# convention, for better or worse. Terse and to the
point.
I tend to use the first variation, but wonder if this makes my code less
readable. Does anyone have a preference for any of these, or any other
variations? I don't want to start a religious war, but am curious about
whether there's a consistent "best practice."

[Fergus Cooney]

Hi Robert,

Shame about number 1. ;-)

I would say the only 'best practice' is don't give your variables the same
name as the class.

Is this a Foo which I see before me,
The handle toward my hand?
Come, let me clutch thee.
I have thee not, and yet I see thee still.

For you are the class not the object,
Or is it the other way round?
And now I'm all confused.
Everything else. I would say, is optional and as varied as you suggest,
and more.

For short pieces of code like a loop, the single letter can be good. I use
'c' for char loops, 'S' for simple string manipulation, 'F' for a Form in a
small Form utility routine, etc. Generally the scope will be small and the
variable used a lot.

For objects in general I use oDis and oDat. (is dat 'cos Oi'm Oirish,
maybe not). It's a habit with history and it's a pretty strong one - but I'm
re-evaluatiing it in .NET. It does have the advantage of using the same name
as the class.

I absolutely <hate> My anything - now <that's> cutesy.

But occasionally I use TheWidget or ThisWidget.

Regards,
Fergus

[Herfried K. Wagner [MVP]]

* "Robert Jacobson" <rj************ **********@nosp am.com> scripsit:

If I have a class called "Foo," is there a preferred naming convention for
iterating through each Foo instance in a collection of Foos? I've seen
several different variations, even in the MSDN documentation:
#1:
For each Foo as Foo in Foos
...
Next Foo

This variation is direct, but a bit ambiguous since it's using the same name
for the Foo class and the Foo instance. (I know that the "Foo" in "Next
Foo" is optional -- I'm just including it for clarity.)
I think that's a really bad convention.
#2:
For each MyFoo [or aFoo, TheFoo, etc.] as Foo in Foos
...
Next MyFoo

This variation eliminates the ambiguity by adding a prefix to the instance
name. However, it seems a bit too "cutesy" for me.
Seems "nice" to me.
#3:
For each f as Foo
...
Next f

This appears to be the C# convention, for better or worse. Terse and to the
point.

The "quick" solution.

--
Herfried K. Wagner
MVP · VB Classic, VB.NET
<http://www.mvps.org/dotnet>

[Robert Jacobson]

LOL! You need to write a book on the Art and Poetry of VB. Now if only you
could come up with bawdy VB limericks. "There was a VB programmer from
Nantucket..."

"Fergus Cooney" <fi******@tesco .net> wrote in message
news:eo******** ******@TK2MSFTN GP10.phx.gbl...

[Snip]

Is this a Foo which I see before me,
The handle toward my hand?
Come, let me clutch thee.
I have thee not, and yet I see thee still.

For you are the class not the object,
Or is it the other way round?
And now I'm all confused.

[Robert Jacobson]

Well, two votes against my typical practice. I'll see if I can live with
aFoo, or the C# variation. Habits are hard to break. <g>
"Herfried K. Wagner [MVP]" <hi************ ***@gmx.at> wrote in message
news:%2******** ********@TK2MSF TNGP09.phx.gbl. ..

* "Robert Jacobson" <rj************ **********@nosp am.com> scripsit:

If I have a class called "Foo," is there a preferred naming convention for iterating through each Foo instance in a collection of Foos? I've seen
several different variations, even in the MSDN documentation:
#1:
For each Foo as Foo in Foos
...
Next Foo

This variation is direct, but a bit ambiguous since it's using the same name for the Foo class and the Foo instance. (I know that the "Foo" in "Next
Foo" is optional -- I'm just including it for clarity.)

I think that's a really bad convention.

#2:
For each MyFoo [or aFoo, TheFoo, etc.] as Foo in Foos
...
Next MyFoo

This variation eliminates the ambiguity by adding a prefix to the instance name. However, it seems a bit too "cutesy" for me.

Seems "nice" to me.

#3:
For each f as Foo
...
Next f

This appears to be the C# convention, for better or worse. Terse and to the point.

The "quick" solution.

--
Herfried K. Wagner
MVP · VB Classic, VB.NET
<http://www.mvps.org/dotnet>

[Rick Mogstad]

"Robert Jacobson" <rj************ **********@nosp am.com> wrote in message
news:%2******** ********@tk2msf tngp13.phx.gbl. ..

Hello all,

If I have a class called "Foo," is there a preferred naming convention for
iterating through each Foo instance in a collection of Foos? I've seen
several different variations, even in the MSDN documentation:
#1:
For each Foo as Foo in Foos
...
Next Foo

This variation is direct, but a bit ambiguous since it's using the same name
for the Foo class and the Foo instance. (I know that the "Foo" in "Next
Foo" is optional -- I'm just including it for clarity.)
Yeah, not my favorite approach. Aids in confusion later.

#2:
For each MyFoo [or aFoo, TheFoo, etc.] as Foo in Foos
...
Next MyFoo

This variation eliminates the ambiguity by adding a prefix to the instance
name. However, it seems a bit too "cutesy" for me.
This is my choice.

#3:
For each f as Foo
...
Next f

This appears to be the C# convention, for better or worse. Terse and to the
point.
This works too, however, if we keep copying what they do in C#, it will only give them more reason
to think they are better than us...


I tend to use the first variation, but wonder if this makes my code less
readable. Does anyone have a preference for any of these, or any other
variations? I don't want to start a religious war, but am curious about
whether there's a consistent "best practice."

[Jay B. Harlow [MVP - Outlook]]

Fergus,

I would say the only 'best practice' is don't give your variables the same name as the class. Curious on where you came up with this idea? ;-)

As it seems to me to be the best practice! As the names should be
descriptive enough that the name & type can be used to determine its
meaning. If the type happens to be the most descriptive name then why not
use it?

In other words if I have a Person object, why not name the field person,
especially when I am dealing with a generic person or I am iterating a
collection of specialized (derived objects) people objects?

I don't have a single web link handy...

Just a thought
Jay

"Fergus Cooney" <fi******@tesco .net> wrote in message
news:eo******** ******@TK2MSFTN GP10.phx.gbl... Hi Robert,

Shame about number 1. ;-)

I would say the only 'best practice' is don't give your variables the same name as the class.

Is this a Foo which I see before me,
The handle toward my hand?
Come, let me clutch thee.
I have thee not, and yet I see thee still.

For you are the class not the object,
Or is it the other way round?
And now I'm all confused.
Everything else. I would say, is optional and as varied as you suggest, and more.

For short pieces of code like a loop, the single letter can be good. I use 'c' for char loops, 'S' for simple string manipulation, 'F' for a Form in a small Form utility routine, etc. Generally the scope will be small and the
variable used a lot.

For objects in general I use oDis and oDat. (is dat 'cos Oi'm Oirish,
maybe not). It's a habit with history and it's a pretty strong one - but I'm re-evaluatiing it in .NET. It does have the advantage of using the same name as the class.

I absolutely <hate> My anything - now <that's> cutesy.

But occasionally I use TheWidget or ThisWidget.

Regards,
Fergus

[Jay B. Harlow [MVP - Outlook]]

Robert,

Does anyone have a preference for any of these, or any other
variations? I use a variation of #1:
For Each foo As Foo in Foos
...
Next
Notice the lower case f in foo, I follow the .NET Design Guidelines for
Class Library Developers and all variables, fields & parameters are
camelCased.

Unless I have a more descriptive name I use the type name, as names should
be descriptive enough that the name & its type can be used to determine its
meaning. If the type happens to be most descriptive then that is the name I
use. On rare occasions will I use an abbreviations of the type, usually when
the type name is a reserved word, for example ch for Char, str for String.

Right now I don't have a specific link.
I don't want to start a religious war, but am curious about
whether there's a consistent "best practice." I don't think there is a best practice per se. I tend to feel as long as you
are consistent within your project, solution, team, enterprise. Remember the
variable you use is more then likely private to the method, so it really
doesn't matter, its there more for your & your teams readability.

Hope this helps
Jay

"Robert Jacobson" <rj************ **********@nosp am.com> wrote in message
news:%2******** ********@tk2msf tngp13.phx.gbl. .. Hello all,

If I have a class called "Foo," is there a preferred naming convention for
iterating through each Foo instance in a collection of Foos? I've seen
several different variations, even in the MSDN documentation:
#1:
For each Foo as Foo in Foos
...
Next Foo

This variation is direct, but a bit ambiguous since it's using the same name for the Foo class and the Foo instance. (I know that the "Foo" in "Next
Foo" is optional -- I'm just including it for clarity.)
#2:
For each MyFoo [or aFoo, TheFoo, etc.] as Foo in Foos
...
Next MyFoo

This variation eliminates the ambiguity by adding a prefix to the instance
name. However, it seems a bit too "cutesy" for me.
#3:
For each f as Foo
...
Next f

This appears to be the C# convention, for better or worse. Terse and to the point.
I tend to use the first variation, but wonder if this makes my code less
readable. Does anyone have a preference for any of these, or any other
variations? I don't want to start a religious war, but am curious about
whether there's a consistent "best practice."

[Cor]

Hi Robert,

When I see this, it reminds me on the first time I started with a database.

For each mare as horse in the stable
'bring it some water
next

I think that your program has to describe what you are doing that is the
first rule in all programming.

Cor

[Herfried K. Wagner [MVP]]

* "Rick Mogstad" <ri**@NOSPAM.co mputetosuit.com > scripsit:

#2:
For each MyFoo [or aFoo, TheFoo, etc.] as Foo in Foos
...
Next MyFoo

This variation eliminates the ambiguity by adding a prefix to the instance
name. However, it seems a bit too "cutesy" for me.

This is my choice.

#3:
For each f as Foo
...
Next f

This appears to be the C# convention, for better or worse. Terse and to the
point.

This works too, however, if we keep copying what they do in C#, it will only give them more reason
to think they are better than us...

I often used something like 'f' for loop variables very long time before
C# has been invented.

--
Herfried K. Wagner
MVP · VB Classic, VB.NET
<http://www.mvps.org/dotnet>