Interface and overloaded functions in visual studio.NET

[sotto]

If i have this Interface:

Public Interface MyInterface
Function test() As Boolean
Function test(ByVal MyVar As String) As Boolean
End Interface

And then i make a

Public Class MyOwnClass
Implements MyInterface
End Class

When i hit [Enter] after the Implements MyInterface
Visual Studio automatically creates

Public Overloads Function test() As Boolean Implements MyInterface.tes t
End Function

Public Overloads Function test1(ByVal MyVar As String) As Boolean
Implements MyInterface.tes t
End Function

These two functions for me...

Why does it add the 1 on the overloaded function-name?
Why doesn't it just make a test() and a test(ByVal Myvar As string)
function?
Is there a specific reason for this behaviour?

[Armin Zingler]

"sotto" <ju**@sotto.inv alid> schrieb

If i have this Interface:

Public Interface MyInterface
Function test() As Boolean
Function test(ByVal MyVar As String) As Boolean
End Interface

And then i make a

Public Class MyOwnClass
Implements MyInterface
End Class

When i hit [Enter] after the Implements MyInterface
Visual Studio automatically creates

Public Overloads Function test() As Boolean Implements
MyInterface.tes t End Function

Public Overloads Function test1(ByVal MyVar As String) As Boolean
Implements MyInterface.tes t
End Function

These two functions for me...

Why does it add the 1 on the overloaded function-name?
Why doesn't it just make a test() and a test(ByVal Myvar As string)
function?
Is there a specific reason for this behaviour?

If you've already got a procedure with the name "test", the IDE uses this
kind of numbering. In this case, it wouldn't be necessary, so you're right.
I'd post it again in microsoft.publi c.vsnet.ide.
--
Armin

http://www.plig.net/nnq/nquote.html
http://www.netmeister.org/news/learn2quote.html

[Herfried K. Wagner [MVP]]

* sotto <ju**@sotto.inv alid> scripsit:

If i have this Interface:

Public Interface MyInterface
Function test() As Boolean
Function test(ByVal MyVar As String) As Boolean
End Interface

And then i make a

Public Class MyOwnClass
Implements MyInterface
End Class

When i hit [Enter] after the Implements MyInterface
Visual Studio automatically creates

Public Overloads Function test() As Boolean Implements MyInterface.tes t
End Function

Public Overloads Function test1(ByVal MyVar As String) As Boolean
Implements MyInterface.tes t

End Function

These two functions for me...

Why does it add the 1 on the overloaded function-name?
Why doesn't it just make a test() and a test(ByVal Myvar As string)
function?

Is there a specific reason for this behaviour?

I currently don't have VS.NET 2003 here, but if it names it with an "1"
at the end of the name it is maybe a bug.

--
Herfried K. Wagner [MVP]
<http://www.mvps.org/dotnet>

[Trev Hunter]

> I currently don't have VS.NET 2003 here, but if it

names it with an "1" at the end of the name it is maybe a bug.
I use VS2003 and it does name overloaded interface methods with an number
suffix.

e.g.

Test()
Test1()
Test2()

etc.

Trev.
"Herfried K. Wagner [MVP]" <hi************ ***@gmx.at> wrote in message
news:ez******** *****@TK2MSFTNG P10.phx.gbl... * sotto <ju**@sotto.inv alid> scripsit:

If i have this Interface:

Public Interface MyInterface
Function test() As Boolean
Function test(ByVal MyVar As String) As Boolean
End Interface

And then i make a

Public Class MyOwnClass
Implements MyInterface
End Class

When i hit [Enter] after the Implements MyInterface
Visual Studio automatically creates

Public Overloads Function test() As Boolean Implements MyInterface.tes t
End Function

Public Overloads Function test1(ByVal MyVar As String) As Boolean
Implements MyInterface.tes t

End Function

These two functions for me...

Why does it add the 1 on the overloaded function-name?
Why doesn't it just make a test() and a test(ByVal Myvar As string)
function?

Is there a specific reason for this behaviour?

I currently don't have VS.NET 2003 here, but if it names it with an "1"
at the end of the name it is maybe a bug.

--
Herfried K. Wagner [MVP]
<http://www.mvps.org/dotnet>

[Philip Rieck]

VS.net uses "proc", "proc1", "proc2" .... type naming when generating
function names for you. If it generates "proc", but that name already
exists, then it will try "proc1". If that exists, it will try "proc2", and
so on...

While the generator COULD use method overloads, overloading a method only
makes sense if the functions are closely related. VS.NET really doesn't
know if they're related or not, so it names them uniquely. This naming is
applied in all cases, even when using the same name isn't an issue.
"sotto" <ju**@sotto.inv alid> wrote in message
news:G9******** *************@h estia.telenet-ops.be...

If i have this Interface:

Public Interface MyInterface
Function test() As Boolean
Function test(ByVal MyVar As String) As Boolean
End Interface

And then i make a

Public Class MyOwnClass
Implements MyInterface
End Class

When i hit [Enter] after the Implements MyInterface
Visual Studio automatically creates

Public Overloads Function test() As Boolean Implements MyInterface.tes t
End Function

Public Overloads Function test1(ByVal MyVar As String) As Boolean
Implements MyInterface.tes t
End Function

These two functions for me...

Why does it add the 1 on the overloaded function-name?
Why doesn't it just make a test() and a test(ByVal Myvar As string)
function?
Is there a specific reason for this behaviour?

[Jay B. Harlow [MVP - Outlook]]

Herfried,
As Trev stated, it "numbers" the members when they are overloaded, I suspect
for the reason Armin cited.

The numbering partially makes senses when the class had a Test function with
a different return type before I added the interface! I'm sure numbering is
the "easy way" to implement it. ;-)

However! more oft then not, I do not want the methods numbered, I either
want implicitly or explicit interface implementation (to borrow the C#
term).

' implicit interface implementation

Public Function test() As Boolean Implements MyInterface.tes t
End Function

Public Function test(ByVal MyVar As String) As Boolean
Implements MyInterface.tes t

Public Function test() As String
End Function

' explicit interface implementation Private Function MyInterface_tes t() As Boolean Implements MyInterface.tes t End Function

Private Function MyInterface_tes t(ByVal MyVar As String) As Boolean
Implements MyInterface.tes t

Also in this context the Overloads normally is not needed, I'm suspect its
injected incase I am implementing the interface in a class that already has
a Test method inherited from a base class.

Just a thought
Jay

"Herfried K. Wagner [MVP]" <hi************ ***@gmx.at> wrote in message
news:ez******** *****@TK2MSFTNG P10.phx.gbl... * sotto <ju**@sotto.inv alid> scripsit:

If i have this Interface:

Public Interface MyInterface
Function test() As Boolean
Function test(ByVal MyVar As String) As Boolean
End Interface

And then i make a

Public Class MyOwnClass
Implements MyInterface
End Class

When i hit [Enter] after the Implements MyInterface
Visual Studio automatically creates

Public Overloads Function test() As Boolean Implements MyInterface.tes t
End Function

Public Overloads Function test1(ByVal MyVar As String) As Boolean
Implements MyInterface.tes t

End Function

These two functions for me...

Why does it add the 1 on the overloaded function-name?
Why doesn't it just make a test() and a test(ByVal Myvar As string)
function?

Is there a specific reason for this behaviour?

I currently don't have VS.NET 2003 here, but if it names it with an "1"
at the end of the name it is maybe a bug.

--
Herfried K. Wagner [MVP]
<http://www.mvps.org/dotnet>

[Herfried K. Wagner [MVP]]

* "Jay B. Harlow [MVP - Outlook]" <Ja************ @msn.com> scripsit:

The numbering partially makes senses when the class had a Test function with
a different return type before I added the interface! I'm sure numbering is
the "easy way" to implement it. ;-)
Seems to be a "quick and dirty" solution...

;-)
However! more oft then not, I do not want the methods numbered, I either
want implicitly or explicit interface implementation (to borrow the C#
term).

I don't like numbered methods too.

--
Herfried K. Wagner [MVP]
<http://www.mvps.org/dotnet>

[Jay B. Harlow [MVP - Outlook]]

Herfried,
Aren't "easy way" and "quick and dirty" synonyms?

:-))

Jay

"Herfried K. Wagner [MVP]" <hi************ ***@gmx.at> wrote in message
news:bu******** ****@ID-208219.news.uni-berlin.de...

* "Jay B. Harlow [MVP - Outlook]" <Ja************ @msn.com> scripsit:

The numbering partially makes senses when the class had a Test function with a different return type before I added the interface! I'm sure numbering is the "easy way" to implement it. ;-)

Seems to be a "quick and dirty" solution...

;-)

However! more oft then not, I do not want the methods numbered, I either
want implicitly or explicit interface implementation (to borrow the C#
term).

I don't like numbered methods too.

--
Herfried K. Wagner [MVP]
<http://www.mvps.org/dotnet>

[Cor]

Hi Jay B,

I hope you don't mind I answer also?

Aren't "easy way" and "quick and dirty" synonyms?

I think not, they are opposites in my eyes.

Keep it simple is not only a term I often use.

If you cannot "Keep it simple", the "quick and dirty" way is mostly the bad
solution.
(About that we do not have to argue).

Just a thought,

Cor

[Trev Hunter]

> Aren't "easy way" and "quick and dirty" synonyms?

"easy way", "quick and dirty" and "quick and beautiful" are in the eyes of
the beholder ;)