Naming convention for inner functions

[Telmo Costa]

What should i call the functions named Factorial_ in this sample code:

class SomeClass {

...
public int Factorial(int f) {
if (f<0) throw SomeException("Some message.");
if (f==0 || f==1) return 1;
return Factorial_(f);
}

private int Factorial_(int f) {
if (f==1) return 1;
return f*Factorial_(f-1);
}
...
}

Calling it Factorial_ looks bad. Cannot call Factorial because it is the
name that the public method should have. What should it be?

telmo

[Marina]

Why do you need 2 functions? Can't you combine this into 1?

It is usually not an issue, since most of the time there wouldn't be a
conflict between the names like that. But when it does happen, I would guess
everyone has their own conventions.

"Telmo Costa" <te*********@netvisao.pt> wrote in message
news:ne********************@newsfront4.netvisao.pt ...

What should i call the functions named Factorial_ in this sample code:

class SomeClass {

...
public int Factorial(int f) {
if (f<0) throw SomeException("Some message.");
if (f==0 || f==1) return 1;
return Factorial_(f);
}

private int Factorial_(int f) {
if (f==1) return 1;
return f*Factorial_(f-1);
}
...
}

Calling it Factorial_ looks bad. Cannot call Factorial because it is the
name that the public method should have. What should it be?

telmo

[Mark R. Dawson]

I don't believe there is any real convention for how to name private
functions. In your example I would name it something like FactorialInternal.
"Telmo Costa" wrote:

What should i call the functions named Factorial_ in this sample code:

class SomeClass {

...
public int Factorial(int f) {
if (f<0) throw SomeException("Some message.");
if (f==0 || f==1) return 1;
return Factorial_(f);
}

private int Factorial_(int f) {
if (f==1) return 1;
return f*Factorial_(f-1);
}
...
}

Calling it Factorial_ looks bad. Cannot call Factorial because it is the
name that the public method should have. What should it be?

telmo

[Telmo Costa]

Marina wrote:

Why do you need 2 functions? Can't you combine this into 1?
Factorial was just an example.
There are many situations where functions cannot be combine. In this
case is just because Factorial_ is a recursive function and Factorial
code should be executed only once.

What should i call the functions named Factorial_ in this sample code:

class SomeClass {

...
public int Factorial(int f) {
if (f<0) throw SomeException("Some message.");
if (f==0 || f==1) return 1;
return Factorial_(f);
}

private int Factorial_(int f) {
if (f==1) return 1;
return f*Factorial_(f-1);
}
...
}

Calling it Factorial_ looks bad. Cannot call Factorial because it is the
name that the public method should have. What should it be?

telmo

[Octavio Hernandez]

Hi,

One recommendation is to name private elements of classes with names
starting with lowercase letter, so you could use 'factorial',
'factorialHelper', etc.

Regards - Octavio

"Telmo Costa" <te*********@netvisao.pt> escribió en el mensaje
news:ne********************@newsfront4.netvisao.pt ...

What should i call the functions named Factorial_ in this sample code:

class SomeClass {

...
public int Factorial(int f) {
if (f<0) throw SomeException("Some message.");
if (f==0 || f==1) return 1;
return Factorial_(f);
}

private int Factorial_(int f) {
if (f==1) return 1;
return f*Factorial_(f-1);
}
...
}

Calling it Factorial_ looks bad. Cannot call Factorial because it is the
name that the public method should have. What should it be?

telmo

[Jon Skeet [C# MVP]]

Octavio Hernandez <do****@danysoft.com> wrote:

One recommendation is to name private elements of classes with names
starting with lowercase letter, so you could use 'factorial',
'factorialHelper', etc.

I've never seen that, and it goes against the MS naming conventions,
which state that Pascal case should be used. There's nothing saying
that's only for public methods, and changing it just for private
methods introduces inconsistency in my view.

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

[Octavio Hernandez]

Jon,

Thanks for the correction! You're absolutely right regarding naming
guidelines for methods (by the way, here is the link for readers interested)

http://msdn.microsoft.com/library/de...guidelines.asp

Maybe I've violated them 2 or 3 times :-)

Regards - Octavio

"Jon Skeet [C# MVP]" <sk***@pobox.com> escribió en el mensaje
news:MP************************@msnews.microsoft.c om...

Octavio Hernandez <do****@danysoft.com> wrote:

One recommendation is to name private elements of classes with names
starting with lowercase letter, so you could use 'factorial',
'factorialHelper', etc.

I've never seen that, and it goes against the MS naming conventions,
which state that Pascal case should be used. There's nothing saying
that's only for public methods, and changing it just for private
methods introduces inconsistency in my view.

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

[Jon Skeet [C# MVP]]

Octavio Hernandez <do****@danysoft.com> wrote:

One recommendation is to name private elements of classes with names
starting with lowercase letter, so you could use 'factorial',
'factorialHelper', etc.

I've never seen that, and it goes against the MS naming conventions,
which state that Pascal case should be used. There's nothing saying
that's only for public methods, and changing it just for private
methods introduces inconsistency in my view.

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

[Octavio Hernandez]

Jon,

Thanks for the correction! You're absolutely right regarding naming
guidelines for methods (by the way, here is the link for readers interested)

http://msdn.microsoft.com/library/de...guidelines.asp

Maybe I've violated them 2 or 3 times :-)

Regards - Octavio

"Jon Skeet [C# MVP]" <sk***@pobox.com> escribió en el mensaje
news:MP************************@msnews.microsoft.c om...

Octavio Hernandez <do****@danysoft.com> wrote:

One recommendation is to name private elements of classes with names
starting with lowercase letter, so you could use 'factorial',
'factorialHelper', etc.

I've never seen that, and it goes against the MS naming conventions,
which state that Pascal case should be used. There's nothing saying
that's only for public methods, and changing it just for private
methods introduces inconsistency in my view.

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

[Daniel O'Connell [C# MVP]]

"Telmo Costa" <te*********@netvisao.pt> wrote in message
news:ne********************@newsfront4.netvisao.pt ...

What should i call the functions named Factorial_ in this sample code:

I usually use something like InternalXxx if the method is non-virtual, and
something like XxxCore or XxxImpl if the method is virtual.

[Daniel O'Connell [C# MVP]]

"Telmo Costa" <te*********@netvisao.pt> wrote in message
news:ne********************@newsfront4.netvisao.pt ...

What should i call the functions named Factorial_ in this sample code:

I usually use something like InternalXxx if the method is non-virtual, and
something like XxxCore or XxxImpl if the method is virtual.

[Bruce Wood]

It's very rare that I write a private method that does _exactly the
same_ thing as a public method, and so run into such a naming conflict.
I would be tempted to call it something like CalculateFactorial().

I find it far more common that the private method does some _part_ of a
larger job, in which case I name it based on what it does without
running into a naming conflict.

Be careful that by creating an "internal method" naming convention you
don't encourage people to start blindly naming their methods
XxxInternal just because they're used from the Xxx public method,
without really considering what the internal method is doing.

[Bruce Wood]

It's very rare that I write a private method that does _exactly the
same_ thing as a public method, and so run into such a naming conflict.
I would be tempted to call it something like CalculateFactorial().

I find it far more common that the private method does some _part_ of a
larger job, in which case I name it based on what it does without
running into a naming conflict.

Be careful that by creating an "internal method" naming convention you
don't encourage people to start blindly naming their methods
XxxInternal just because they're used from the Xxx public method,
without really considering what the internal method is doing.