VB.NET-101 Constructors and Methods

[John]

Trying to find out what is essential / optional, I made an extremely simple
Class and Module combination to add two numbers. (see below)

It appears that an empty constructor is needed n order to work right,
although I quite don't see what is does in addition to the 2nd constructor.

Also, the example works fine without message calls in either constructor
(the numerical answer is still there and correct!).
I exected it to no longer work and return build or run errors.
Please explain,

Thanks for your help,
John

***************
Public Class CSum

Public mSum As Integer

Public Sub New()
'Sum(0, 0)
End Sub

Public Sub New(ByVal firstNumber As Integer, ByVal lastNumber As Integer)
'Sum(firstNumbe r, lastNumber)
End Sub

Public Sub Sum(ByVal firstNumber As Integer, ByVal lastNumber As Integer)
mSum = firstNumber + lastNumber
End Sub

End Class

Module Module1

Sub Main()

Dim thisFirstNumber As Integer = 10
Dim thisLastNumber As Integer = 100

Dim thisSum As New CSum

thisSum.Sum(thi sFirstNumber, thisLastNumber)

Console.WriteLi ne("The sum of {0} and {1} = {2}", _
thisFirstNumber , thisLastNumber, thisSum.mSum)

End Sub

End Module

[Marina]

An empty one is needed if you don't want to call the one with 2 paramters.
You declared the other constructor, but you are not using. Now that it's
there, if you want to use an empty constructor, you havet o add it (as you
did).

I'm not sure why you expected errors. You called the Sum method. Then you
retrieved the result - makes sense that it shoudl all work to me.

"John" <Jo**@discussio ns.microsoft.co m> wrote in message
news:2B******** *************** ***********@mic rosoft.com...

Trying to find out what is essential / optional, I made an extremely
simple
Class and Module combination to add two numbers. (see below)

It appears that an empty constructor is needed n order to work right,
although I quite don't see what is does in addition to the 2nd
constructor.

Also, the example works fine without message calls in either constructor
(the numerical answer is still there and correct!).
I exected it to no longer work and return build or run errors.
Please explain,

Thanks for your help,
John

***************
Public Class CSum

Public mSum As Integer

Public Sub New()
'Sum(0, 0)
End Sub

Public Sub New(ByVal firstNumber As Integer, ByVal lastNumber As
Integer)
'Sum(firstNumbe r, lastNumber)
End Sub

Public Sub Sum(ByVal firstNumber As Integer, ByVal lastNumber As
Integer)
mSum = firstNumber + lastNumber
End Sub

End Class

Module Module1

Sub Main()

Dim thisFirstNumber As Integer = 10
Dim thisLastNumber As Integer = 100

Dim thisSum As New CSum

thisSum.Sum(thi sFirstNumber, thisLastNumber)

Console.WriteLi ne("The sum of {0} and {1} = {2}", _
thisFirstNumber , thisLastNumber, thisSum.mSum)

End Sub

End Module

[John]

I "commented out" the functions calls in both constructors. In all examples
in my book seen so far, where a method with X parameters was used, method
calls with X arguments (unless optional) were placed in each constructor.
Do I now understand that such message calls are not always needed?
When are they needed and when not?

Thanks for your help.
John

"Marina" wrote:

An empty one is needed if you don't want to call the one with 2 paramters.
You declared the other constructor, but you are not using. Now that it's
there, if you want to use an empty constructor, you havet o add it (as you
did).

I'm not sure why you expected errors. You called the Sum method. Then you
retrieved the result - makes sense that it shoudl all work to me.

"John" <Jo**@discussio ns.microsoft.co m> wrote in message
news:2B******** *************** ***********@mic rosoft.com...

Trying to find out what is essential / optional, I made an extremely
simple
Class and Module combination to add two numbers. (see below)

It appears that an empty constructor is needed n order to work right,
although I quite don't see what is does in addition to the 2nd
constructor.

Also, the example works fine without message calls in either constructor
(the numerical answer is still there and correct!).
I exected it to no longer work and return build or run errors.
Please explain,

Thanks for your help,
John

***************
Public Class CSum

Public mSum As Integer

Public Sub New()
'Sum(0, 0)
End Sub

Public Sub New(ByVal firstNumber As Integer, ByVal lastNumber As
Integer)
'Sum(firstNumbe r, lastNumber)
End Sub

Public Sub Sum(ByVal firstNumber As Integer, ByVal lastNumber As
Integer)
mSum = firstNumber + lastNumber
End Sub

End Class

Module Module1

Sub Main()

Dim thisFirstNumber As Integer = 10
Dim thisLastNumber As Integer = 100

Dim thisSum As New CSum

thisSum.Sum(thi sFirstNumber, thisLastNumber)

Console.WriteLi ne("The sum of {0} and {1} = {2}", _
thisFirstNumber , thisLastNumber, thisSum.mSum)

End Sub

End Module

[Marina]

Sorry, I am not following at all as far as what the parameters in your
methods have to do with your constructors. They are completely separate and
unrelated.

Delete all the constructors in that class you posted as an example. Have
just the Sum method left and variable declaration. Everything should work
fine.

Might be time to get a new book.

"John" <Jo**@discussio ns.microsoft.co m> wrote in message
news:84******** *************** ***********@mic rosoft.com...

I "commented out" the functions calls in both constructors. In all examples
in my book seen so far, where a method with X parameters was used, method
calls with X arguments (unless optional) were placed in each constructor.
Do I now understand that such message calls are not always needed?
When are they needed and when not?

Thanks for your help.
John

"Marina" wrote:

An empty one is needed if you don't want to call the one with 2
paramters.
You declared the other constructor, but you are not using. Now that it's
there, if you want to use an empty constructor, you havet o add it (as
you
did).

I'm not sure why you expected errors. You called the Sum method. Then you
retrieved the result - makes sense that it shoudl all work to me.

"John" <Jo**@discussio ns.microsoft.co m> wrote in message
news:2B******** *************** ***********@mic rosoft.com...

> Trying to find out what is essential / optional, I made an extremely
> simple
> Class and Module combination to add two numbers. (see below)
>
> It appears that an empty constructor is needed n order to work right,
> although I quite don't see what is does in addition to the 2nd
> constructor.
>
> Also, the example works fine without message calls in either
> constructor
> (the numerical answer is still there and correct!).
> I exected it to no longer work and return build or run errors.
> Please explain,
>
> Thanks for your help,
> John
>
> ***************
> Public Class CSum
>
> Public mSum As Integer
>
> Public Sub New()
> 'Sum(0, 0)
> End Sub
>
> Public Sub New(ByVal firstNumber As Integer, ByVal lastNumber As
> Integer)
> 'Sum(firstNumbe r, lastNumber)
> End Sub
>
> Public Sub Sum(ByVal firstNumber As Integer, ByVal lastNumber As
> Integer)
> mSum = firstNumber + lastNumber
> End Sub
>
> End Class
>
> Module Module1
>
> Sub Main()
>
> Dim thisFirstNumber As Integer = 10
> Dim thisLastNumber As Integer = 100
>
> Dim thisSum As New CSum
>
> thisSum.Sum(thi sFirstNumber, thisLastNumber)
>
> Console.WriteLi ne("The sum of {0} and {1} = {2}", _
> thisFirstNumber , thisLastNumber, thisSum.mSum)
>
> End Sub
>
> End Module

[_AnonCoward]

"John" <Jo**@discussio ns.microsoft.co m> wrote in message
news:2B******** *************** ***********@mic rosoft.com...
:
: Trying to find out what is essential / optional, I made an extremely
: simple Class and Module combination to add two numbers. (see below)
:
: It appears that an empty constructor is needed n order to work right,
: although I quite don't see what is does in addition to the 2nd
: constructor.
:
: Also, the example works fine without message calls in either
: constructor (the numerical answer is still there and correct!).
: I exected it to no longer work and return build or run errors.
: Please explain,
:
: Thanks for your help,
: John
:
: ***************
: Public Class CSum
:
: Public mSum As Integer
:
: Public Sub New()
: 'Sum(0, 0)
: End Sub
:
: Public Sub New(ByVal firstNumber As Integer, _
: ByVal lastNumber As Integer)
: 'Sum(firstNumbe r, lastNumber)
: End Sub
:
: Public Sub Sum(ByVal firstNumber As Integer, _
: ByVal lastNumber As Integer)
: mSum = firstNumber + lastNumber
: End Sub
:
: End Class
:
: Module Module1
:
: Sub Main()
:
: Dim thisFirstNumber As Integer = 10
: Dim thisLastNumber As Integer = 100
:
: Dim thisSum As New CSum
:
: thisSum.Sum(thi sFirstNumber, thisLastNumber)
:
: Console.WriteLi ne("The sum of {0} and {1} = {2}", _
: thisFirstNumber , thisLastNumber, thisSum.mSum)
:
: End Sub
:
: End Module
I'll be honest and acknowledge up front I'm not entirely sure what you
are asking, so plz forgive me if this doesn't address your qurestion.
The constructors are needed in order to instantiate the class CSum. The
2nd constructor is in fact unneeded in the context you've offered here.
The Sub 'Sum' stands alone - all you need is an instance of the CSum
class and you can call it from there:

'************** *************** *************** ***
Imports System

Public Class CSum
Public mSum As Integer

Public Sub New()
End Sub

Public Sub Sum(ByVal firstNumber As Integer, _
ByVal lastNumber As Integer)
mSum = firstNumber + lastNumber
End Sub

End Class

Module Module1
Sub Main()
Dim thisFirstNumber As Integer = 10
Dim thisLastNumber As Integer = 100
Dim thisSum As New CSum

thisSum.Sum(thi sFirstNumber, thisLastNumber)

Console.WriteLi ne("The sum of {0} and {1} = {2}", _
thisFirstNumber , thisLastNumber, thisSum.mSum)
End Sub
End Module

'************** *************** *************** ***
As an alternative, you could have instead declared the CSum class as a
structure. In this case, no contructor is needed at all (in fact, you
get compile errors if you declare an empty structure (uncomment the Sub
New() lines below to see what I mean):
'************** *************** *************** ***
Public Structure CSum
Public mSum As Integer

' Public Sub New()
' End Sub

Public Sub Sum(ByVal firstNumber As Integer, _
ByVal lastNumber As Integer)
mSum = firstNumber + lastNumber
End Sub

End Structure

'************** *************** *************** ***
An alternative approach would be to declare Sum as a shared fuction:

'************** *************** *************** ***
Imports System

Public Class CSum
Public mSum As Integer

Private Sub New()
End Sub

Public Shared Function Sum( _
ByVal firstNumber As Integer, _
ByVal lastNumber As Integer) As Integer
Return firstNumber + lastNumber
End Function

End Class

Module Module1
Sub Main()
Dim thisFirstNumber As Integer = 10
Dim thisLastNumber As Integer = 100
Dim thisSum As Integer

thisSum = CSum.Sum(thisFi rstNumber, thisLastNumber)

Console.WriteLi ne("The sum of {0} and {1} = {2}", _
thisFirstNumber , thisLastNumber, thisSum)
End Sub
End Module

'************** *************** *************** ***

In this case, you can't create an instance of the CSum class as there
aren't any publicly accessible constructors you can invoke with the New
keyword.

HTH,

Ralf

[Workgroups]

Perhaps this is what's tripping you up? Methods can have "multiple
signatures", allowing more than two of the same name:

Sub New ()

We'll call this "Signature #1". And then this...

Sub New (ByVal firstNumber As Integer, ByVal lastNumber As Integer)

We'll call that "Signature #2".

Both of these subroutines called New have the same name, but, they have
different parameter lists (different datatypes in a different order) in
their declarations. This gives each of them a unique "signature" , a way
for the compiler and the IDE (and you) to tell the difference between them,
and allows them to exist as completely seperate methods despite having the
same name. Signature #1 has no parmeters, whereas signature #2 has two
integer parameters. These differences are enough to qualify them as unique,
individual methods.

By having 2 "New" constructors in your CSum class, you have provided
yourself with 2 constructors (with different signatures) from which to
choose when creating your class. You can call whichever one you want when
instantiating your class. Class CSum doesn't care which you use. All you
have to do is make your constructor call something that matches one of the
signatures. I.e.,

Dim thisSum As New CSum(10, 100)

That passed two integers to construct a New CSum class object. Since we do
indeed have a constructor that will accept two integers ("New" having
Signature #2), that is the constructor that will be utilized (and Signature
#1 will not be utilized at all, in this case).

Alternatively if you were to say,

Dim thisSum As New CSum

Because no parameters were passed to the constructor, this matches Signature
#1, the parameter-less constructor, and so that is chosen instead of
Signature #2.

The alternative to all of this "multiple signature" business would be to
create a single New constructor with 2 optional integers. It would net you
the same conceptual result. But creating multiple signatures of the same
method is typically a cleaner way of doing it if the amount of parameters is
lengthy, so you don't end up with a method with an optional parameter list a
mile long. Instead, you can make different versions of the same method
(with different signatures) that all eventually call a single base worker
sub, etc.

"John" <Jo**@discussio ns.microsoft.co m> wrote in message
news:84******** *************** ***********@mic rosoft.com...

I "commented out" the functions calls in both constructors. In all examples
in my book seen so far, where a method with X parameters was used, method
calls with X arguments (unless optional) were placed in each constructor.
Do I now understand that such message calls are not always needed?
When are they needed and when not?

Thanks for your help.
John

"Marina" wrote:

An empty one is needed if you don't want to call the one with 2
paramters.
You declared the other constructor, but you are not using. Now that it's
there, if you want to use an empty constructor, you havet o add it (as
you
did).

I'm not sure why you expected errors. You called the Sum method. Then you
retrieved the result - makes sense that it shoudl all work to me.

"John" <Jo**@discussio ns.microsoft.co m> wrote in message
news:2B******** *************** ***********@mic rosoft.com...

> Trying to find out what is essential / optional, I made an extremely
> simple
> Class and Module combination to add two numbers. (see below)
>
> It appears that an empty constructor is needed n order to work right,
> although I quite don't see what is does in addition to the 2nd
> constructor.
>
> Also, the example works fine without message calls in either
> constructor
> (the numerical answer is still there and correct!).
> I exected it to no longer work and return build or run errors.
> Please explain,
>
> Thanks for your help,
> John
>
> ***************
> Public Class CSum
>
> Public mSum As Integer
>
> Public Sub New()
> 'Sum(0, 0)
> End Sub
>
> Public Sub New(ByVal firstNumber As Integer, ByVal lastNumber As
> Integer)
> 'Sum(firstNumbe r, lastNumber)
> End Sub
>
> Public Sub Sum(ByVal firstNumber As Integer, ByVal lastNumber As
> Integer)
> mSum = firstNumber + lastNumber
> End Sub
>
> End Class
>
> Module Module1
>
> Sub Main()
>
> Dim thisFirstNumber As Integer = 10
> Dim thisLastNumber As Integer = 100
>
> Dim thisSum As New CSum
>
> thisSum.Sum(thi sFirstNumber, thisLastNumber)
>
> Console.WriteLi ne("The sum of {0} and {1} = {2}", _
> thisFirstNumber , thisLastNumber, thisSum.mSum)
>
> End Sub
>
> End Module

[gg]

pardon me for jumping in.
Please explain when and why would one use shared function without static
variable inside?

I am new to .net and trying to lean. SO please forgive me if I asked a dump
question.

"_AnonCowar d" <ab*@xyz.com> wrote in message
news:X_******** *************@t wister.southeas t.rr.com...

"John" <Jo**@discussio ns.microsoft.co m> wrote in message
news:2B******** *************** ***********@mic rosoft.com...
:
: Trying to find out what is essential / optional, I made an extremely
: simple Class and Module combination to add two numbers. (see below)
:
: It appears that an empty constructor is needed n order to work right,
: although I quite don't see what is does in addition to the 2nd
: constructor.
:
: Also, the example works fine without message calls in either
: constructor (the numerical answer is still there and correct!).
: I exected it to no longer work and return build or run errors.
: Please explain,
:
: Thanks for your help,
: John
:
: ***************
: Public Class CSum
:
: Public mSum As Integer
:
: Public Sub New()
: 'Sum(0, 0)
: End Sub
:
: Public Sub New(ByVal firstNumber As Integer, _
: ByVal lastNumber As Integer)
: 'Sum(firstNumbe r, lastNumber)
: End Sub
:
: Public Sub Sum(ByVal firstNumber As Integer, _
: ByVal lastNumber As Integer)
: mSum = firstNumber + lastNumber
: End Sub
:
: End Class
:
: Module Module1
:
: Sub Main()
:
: Dim thisFirstNumber As Integer = 10
: Dim thisLastNumber As Integer = 100
:
: Dim thisSum As New CSum
:
: thisSum.Sum(thi sFirstNumber, thisLastNumber)
:
: Console.WriteLi ne("The sum of {0} and {1} = {2}", _
: thisFirstNumber , thisLastNumber, thisSum.mSum)
:
: End Sub
:
: End Module
I'll be honest and acknowledge up front I'm not entirely sure what you
are asking, so plz forgive me if this doesn't address your qurestion.
The constructors are needed in order to instantiate the class CSum. The
2nd constructor is in fact unneeded in the context you've offered here.
The Sub 'Sum' stands alone - all you need is an instance of the CSum
class and you can call it from there:

'************** *************** *************** ***
Imports System

Public Class CSum
Public mSum As Integer

Public Sub New()
End Sub

Public Sub Sum(ByVal firstNumber As Integer, _
ByVal lastNumber As Integer)
mSum = firstNumber + lastNumber
End Sub

End Class

Module Module1
Sub Main()
Dim thisFirstNumber As Integer = 10
Dim thisLastNumber As Integer = 100
Dim thisSum As New CSum

thisSum.Sum(thi sFirstNumber, thisLastNumber)

Console.WriteLi ne("The sum of {0} and {1} = {2}", _
thisFirstNumber , thisLastNumber, thisSum.mSum)
End Sub
End Module

'************** *************** *************** ***
As an alternative, you could have instead declared the CSum class as a
structure. In this case, no contructor is needed at all (in fact, you
get compile errors if you declare an empty structure (uncomment the Sub
New() lines below to see what I mean):
'************** *************** *************** ***
Public Structure CSum
Public mSum As Integer

' Public Sub New()
' End Sub

Public Sub Sum(ByVal firstNumber As Integer, _
ByVal lastNumber As Integer)
mSum = firstNumber + lastNumber
End Sub

End Structure

'************** *************** *************** ***
An alternative approach would be to declare Sum as a shared fuction:

'************** *************** *************** ***
Imports System

Public Class CSum
Public mSum As Integer

Private Sub New()
End Sub

Public Shared Function Sum( _
ByVal firstNumber As Integer, _
ByVal lastNumber As Integer) As Integer
Return firstNumber + lastNumber
End Function

End Class

Module Module1
Sub Main()
Dim thisFirstNumber As Integer = 10
Dim thisLastNumber As Integer = 100
Dim thisSum As Integer

thisSum = CSum.Sum(thisFi rstNumber, thisLastNumber)

Console.WriteLi ne("The sum of {0} and {1} = {2}", _
thisFirstNumber , thisLastNumber, thisSum)
End Sub
End Module

'************** *************** *************** ***

In this case, you can't create an instance of the CSum class as there
aren't any publicly accessible constructors you can invoke with the New
keyword.

HTH,

Ralf

[_AnonCoward]

"gg" <[e-mail] > wrote in message
news:O7******** ******@TK2MSFTN GP09.phx.gbl...
: pardon me for jumping in.
: Please explain when and why would one use shared function without
: static variable inside?
:
: I am new to .net and trying to lean. SO please forgive me if I
: asked a dump question.
According to the documentation that accompanies the SDK:
"The Shared keyword indicates that one or more declared programming
elements are shared. Shared elements are not associated with a specific
instance of a class or structure. You can access them by qualifying them
either with the class or structure name, or with the variable name of a
specific instance of the class or structure."
In short, a Shared (static in C#) function is one that exposes
functionality that is not part of a given instance. Shared functions may
not operate on instance variables. The previous example, while trivial,
is an example:
Public Class CSum
Public Shared Function Sum(ByVal First As Integer, _
ByVal Last As Integer) As Integer
Return First + Last
End Function
End Class
The function simply returns the sum of two integers passed in. You don't
need an instance of the CSum class to access this functionality.
A non-trivial example of a Shared function is the System.Console class.
You cannot create an instance of this class nor do you need to in order
to use the various functions it exposes (e.g.: WriteLine).
HTH

Ralf

[John]

Before anything else, thanks Marina, Workgroups and Ralf, for your help.

(Note, I wrote this similar response before, but it got lost while posting
it!)

As per Marina's response, constructors don't need method calls and a new
objects can be instanciated without having any constructors defined. I tried
it in the example and indeed the sum is correctly calculated.

As per Workgoups, constructors can be overloaded, but that is the same for
all procedures isn't it? In the attached modified example, two methods with
the same name use two and three parameters. It works well with and without
constructors.
What is then the added value of using constructors?

The 2nd part of my original question (and code) referred to the observation
that the method with only two-argument constructor caused a build error which
disappeared after adding the empty constructor. I do not understand why.

*************** ***************
Public Class CSum

Public mSumOfTwo As Integer
Public mSumOfThree As Integer

'Public Sub New()
'End Sub

'Public Sub New(ByVal first As Integer, ByVal second As Integer)
'Sum(0, 0)
'End Sub

'Public Sub New(ByVal first As Integer, ByVal second As Integer, ByVal
third As Integer)
'Sum(0, 0, 0)
'End Sub

Public Sub Sum(ByVal first As Integer, ByVal second As Integer)
mSumOfTwo = first + second

Console.WriteLi ne("The sum of {0} and {1} = {2}", _
first, second, mSumOfTwo)
End Sub

Public Sub Sum(ByVal first As Integer, ByVal second As Integer, ByVal
third As Integer)
mSumOfThree = first + second + third

Console.WriteLi ne("The sum of {0} and {1} and {2} = {3}", _
first, second, third, mSumOfThree)
End Sub

End Class
*************** ***************

Module Module1

Sub Main()

Dim thisFirstNumber As Integer = 10
Dim thisSecondNumbe r As Integer = 100
Dim thisLastNumber As Integer = 1000

Dim thisSum As New CSum

thisSum.Sum(thi sFirstNumber, thisSecondNumbe r)

thisSum.Sum(thi sFirstNumber, thisSecondNumbe r, thisLastNumber)

End Sub

End Module
*************** *************** *******
Again, thanks for your support,

John

*************** *************** *******

"Workgroups " wrote:

Perhaps this is what's tripping you up? Methods can have "multiple
signatures", allowing more than two of the same name:

Sub New ()

We'll call this "Signature #1". And then this...

Sub New (ByVal firstNumber As Integer, ByVal lastNumber As Integer)

We'll call that "Signature #2".

Both of these subroutines called New have the same name, but, they have
different parameter lists (different datatypes in a different order) in
their declarations. This gives each of them a unique "signature" , a way
for the compiler and the IDE (and you) to tell the difference between them,
and allows them to exist as completely seperate methods despite having the
same name. Signature #1 has no parmeters, whereas signature #2 has two
integer parameters. These differences are enough to qualify them as unique,
individual methods.

By having 2 "New" constructors in your CSum class, you have provided
yourself with 2 constructors (with different signatures) from which to
choose when creating your class. You can call whichever one you want when
instantiating your class. Class CSum doesn't care which you use. All you
have to do is make your constructor call something that matches one of the
signatures. I.e.,

Dim thisSum As New CSum(10, 100)

That passed two integers to construct a New CSum class object. Since we do
indeed have a constructor that will accept two integers ("New" having
Signature #2), that is the constructor that will be utilized (and Signature
#1 will not be utilized at all, in this case).

Alternatively if you were to say,

Dim thisSum As New CSum

Because no parameters were passed to the constructor, this matches Signature
#1, the parameter-less constructor, and so that is chosen instead of
Signature #2.

The alternative to all of this "multiple signature" business would be to
create a single New constructor with 2 optional integers. It would net you
the same conceptual result. But creating multiple signatures of the same
method is typically a cleaner way of doing it if the amount of parameters is
lengthy, so you don't end up with a method with an optional parameter list a
mile long. Instead, you can make different versions of the same method
(with different signatures) that all eventually call a single base worker
sub, etc.

"John" <Jo**@discussio ns.microsoft.co m> wrote in message
news:84******** *************** ***********@mic rosoft.com...

I "commented out" the functions calls in both constructors. In all examples
in my book seen so far, where a method with X parameters was used, method
calls with X arguments (unless optional) were placed in each constructor.
Do I now understand that such message calls are not always needed?
When are they needed and when not?

Thanks for your help.
John

"Marina" wrote:

An empty one is needed if you don't want to call the one with 2
paramters.
You declared the other constructor, but you are not using. Now that it's
there, if you want to use an empty constructor, you havet o add it (as
you
did).

I'm not sure why you expected errors. You called the Sum method. Then you
retrieved the result - makes sense that it shoudl all work to me.

"John" <Jo**@discussio ns.microsoft.co m> wrote in message
news:2B******** *************** ***********@mic rosoft.com...
> Trying to find out what is essential / optional, I made an extremely
> simple
> Class and Module combination to add two numbers. (see below)
>
> It appears that an empty constructor is needed n order to work right,
> although I quite don't see what is does in addition to the 2nd
> constructor.
>
> Also, the example works fine without message calls in either
> constructor
> (the numerical answer is still there and correct!).
> I exected it to no longer work and return build or run errors.
> Please explain,
>
> Thanks for your help,
> John
>
> ***************
> Public Class CSum
>
> Public mSum As Integer
>
> Public Sub New()
> 'Sum(0, 0)
> End Sub
>
> Public Sub New(ByVal firstNumber As Integer, ByVal lastNumber As
> Integer)
> 'Sum(firstNumbe r, lastNumber)
> End Sub
>
> Public Sub Sum(ByVal firstNumber As Integer, ByVal lastNumber As
> Integer)
> mSum = firstNumber + lastNumber
> End Sub
>
> End Class
>
> Module Module1
>
> Sub Main()
>
> Dim thisFirstNumber As Integer = 10
> Dim thisLastNumber As Integer = 100
>
> Dim thisSum As New CSum
>
> thisSum.Sum(thi sFirstNumber, thisLastNumber)
>
> Console.WriteLi ne("The sum of {0} and {1} = {2}", _
> thisFirstNumber , thisLastNumber, thisSum.mSum)
>
> End Sub
>
> End Module

[John]

I guess that this tread is no longer followed. I will post it as a new one.
John
*************** *********

"John" wrote:

Before anything else, thanks Marina, Workgroups and Ralf, for your help.

(Note, I wrote this similar response before, but it got lost while posting
it!)

As per Marina's response, constructors don't need method calls and a new
objects can be instanciated without having any constructors defined. I tried
it in the example and indeed the sum is correctly calculated.

As per Workgoups, constructors can be overloaded, but that is the same for
all procedures isn't it? In the attached modified example, two methods with
the same name use two and three parameters. It works well with and without
constructors.
What is then the added value of using constructors?

The 2nd part of my original question (and code) referred to the observation
that the method with only two-argument constructor caused a build error which
disappeared after adding the empty constructor. I do not understand why.

*************** ***************
Public Class CSum

Public mSumOfTwo As Integer
Public mSumOfThree As Integer

'Public Sub New()
'End Sub

'Public Sub New(ByVal first As Integer, ByVal second As Integer)
'Sum(0, 0)
'End Sub

'Public Sub New(ByVal first As Integer, ByVal second As Integer, ByVal
third As Integer)
'Sum(0, 0, 0)
'End Sub

Public Sub Sum(ByVal first As Integer, ByVal second As Integer)
mSumOfTwo = first + second

Console.WriteLi ne("The sum of {0} and {1} = {2}", _
first, second, mSumOfTwo)
End Sub

Public Sub Sum(ByVal first As Integer, ByVal second As Integer, ByVal
third As Integer)
mSumOfThree = first + second + third

Console.WriteLi ne("The sum of {0} and {1} and {2} = {3}", _
first, second, third, mSumOfThree)
End Sub

End Class
*************** ***************

Module Module1

Sub Main()

Dim thisFirstNumber As Integer = 10
Dim thisSecondNumbe r As Integer = 100
Dim thisLastNumber As Integer = 1000

Dim thisSum As New CSum

thisSum.Sum(thi sFirstNumber, thisSecondNumbe r)

thisSum.Sum(thi sFirstNumber, thisSecondNumbe r, thisLastNumber)

End Sub

End Module
*************** *************** *******
Again, thanks for your support,

John

*************** *************** *******

"Workgroups " wrote:

Perhaps this is what's tripping you up? Methods can have "multiple
signatures", allowing more than two of the same name:

Sub New ()

We'll call this "Signature #1". And then this...

Sub New (ByVal firstNumber As Integer, ByVal lastNumber As Integer)

We'll call that "Signature #2".

Both of these subroutines called New have the same name, but, they have
different parameter lists (different datatypes in a different order) in
their declarations. This gives each of them a unique "signature" , a way
for the compiler and the IDE (and you) to tell the difference between them,
and allows them to exist as completely seperate methods despite having the
same name. Signature #1 has no parmeters, whereas signature #2 has two
integer parameters. These differences are enough to qualify them as unique,
individual methods.

By having 2 "New" constructors in your CSum class, you have provided
yourself with 2 constructors (with different signatures) from which to
choose when creating your class. You can call whichever one you want when
instantiating your class. Class CSum doesn't care which you use. All you
have to do is make your constructor call something that matches one of the
signatures. I.e.,

Dim thisSum As New CSum(10, 100)

That passed two integers to construct a New CSum class object. Since we do
indeed have a constructor that will accept two integers ("New" having
Signature #2), that is the constructor that will be utilized (and Signature
#1 will not be utilized at all, in this case).

Alternatively if you were to say,

Dim thisSum As New CSum

Because no parameters were passed to the constructor, this matches Signature
#1, the parameter-less constructor, and so that is chosen instead of
Signature #2.

The alternative to all of this "multiple signature" business would be to
create a single New constructor with 2 optional integers. It would net you
the same conceptual result. But creating multiple signatures of the same
method is typically a cleaner way of doing it if the amount of parameters is
lengthy, so you don't end up with a method with an optional parameter list a
mile long. Instead, you can make different versions of the same method
(with different signatures) that all eventually call a single base worker
sub, etc.

"John" <Jo**@discussio ns.microsoft.co m> wrote in message
news:84******** *************** ***********@mic rosoft.com...

I "commented out" the functions calls in both constructors. In all examples
in my book seen so far, where a method with X parameters was used, method
calls with X arguments (unless optional) were placed in each constructor.
Do I now understand that such message calls are not always needed?
When are they needed and when not?

Thanks for your help.
John

"Marina" wrote:

> An empty one is needed if you don't want to call the one with 2
> paramters.
> You declared the other constructor, but you are not using. Now that it's
> there, if you want to use an empty constructor, you havet o add it (as
> you
> did).
>
> I'm not sure why you expected errors. You called the Sum method. Then you
> retrieved the result - makes sense that it shoudl all work to me.
>
> "John" <Jo**@discussio ns.microsoft.co m> wrote in message
> news:2B******** *************** ***********@mic rosoft.com...
> > Trying to find out what is essential / optional, I made an extremely
> > simple
> > Class and Module combination to add two numbers. (see below)
> >
> > It appears that an empty constructor is needed n order to work right,
> > although I quite don't see what is does in addition to the 2nd
> > constructor.
> >
> > Also, the example works fine without message calls in either
> > constructor
> > (the numerical answer is still there and correct!).
> > I exected it to no longer work and return build or run errors.
> > Please explain,
> >
> > Thanks for your help,
> > John
> >
> > ***************
> > Public Class CSum
> >
> > Public mSum As Integer
> >
> > Public Sub New()
> > 'Sum(0, 0)
> > End Sub
> >
> > Public Sub New(ByVal firstNumber As Integer, ByVal lastNumber As
> > Integer)
> > 'Sum(firstNumbe r, lastNumber)
> > End Sub
> >
> > Public Sub Sum(ByVal firstNumber As Integer, ByVal lastNumber As
> > Integer)
> > mSum = firstNumber + lastNumber
> > End Sub
> >
> > End Class
> >
> > Module Module1
> >
> > Sub Main()
> >
> > Dim thisFirstNumber As Integer = 10
> > Dim thisLastNumber As Integer = 100
> >
> > Dim thisSum As New CSum
> >
> > thisSum.Sum(thi sFirstNumber, thisLastNumber)
> >
> > Console.WriteLi ne("The sum of {0} and {1} = {2}", _
> > thisFirstNumber , thisLastNumber, thisSum.mSum)
> >
> > End Sub
> >
> > End Module
>
>
>