Re: Interface naming conventions
"parkerc" <mrcsparker@gmail.com> wrote in message
news:1157663496.301650.22830@m79g2000cwm.googlegroups.com...
Daniel Dyer wrote:
Increasingly I am seeing people prefixing interface names with an 'I', in
open source apps and in example code on the web. So instead of this:
public interface MyInterface
{
}
we have this:
public interface IMyInterface
{
}
Personally, I really dislike this naming convention. Now, some of the
people who are doing this aren't stupid, so I was wondering if anybody
has
a good explanation for why this is a good idea? Is it symptomatic of an
addiction to Hungarian notation, or this there some more sensible
rationale?
I think that it comes from C#. Personally, I really don't see a
problem with a little Hungarian Notation in regard to interfaces.
A point of clarification, this is *NOT* Hungarian notation. This is an
example of type-based naming, which, Micro$oft incorrectly labelled as
Hungarian.
True Hungarian naming defines prefixes for names based on what the item
represents. Type-based naming defines prefixes based on the data type in the
programming language.
So for example if we had a variable that contained the height of a screen
whose data type in C were unsigned long, then possible names in the two
conventions would be:
Hungarian - hgtScreen
Type naming - ulScreenHeight
The problem is that there is little value in type-based naming. Imagine if
you also had an unsigned long screen color. If you tried to assign this to
the above variable in type based-naming it might look like:
ulScreenHeight = ulScreenColor;
The statement makes no logical sense, but the type-based naming prefix
didn't tell you anything. Compare thiw with Hungarian:
hgtScreen = clrScreen;
One of the main problems with type-based naming is that types can change.
For example in Windoze there is wParam which ceased being a word ages ago,
but they couldn't change the name without breaking users.
Hungarian is not nearly as usefull in an OO language, but it is not as bad
as you were lead to believe from M$'s misuse of the term.
The I convention is relatively harmless, but offers little, if any, benefit.
In addition to the origins in COM as others have mentioned, Eclipse also
uses this convention. According to their convention guidelines, "This
convention aids code readability by making interface names more readily
recognizable." I don't find it necessary myself.
One reason it is used is to simplify naming of interfaces and concrete
implementations of that interface so you can have IFoo interface and the
concrete implementation could be called just Foo. I'll leave it up to you to
decide if this is a good thing or not.
--
Dale King