hey all,

i have the following 2 classes:


Public Class DataAccessLayer
....
....
    Public Sub GetRecords(ByRef ds As DataSet1)
        ds = New DataSet1
        Me.SqlDataAdapter1.Fill(ds)
    End Sub
End Class


Here's the class that uses the above class:

Public Class Class1
    Public Function GetCustomers() As DataSet1
        Dim ds As DataSet1
        Dim dal As New DataAccessLayer
        dal.GetRecords(ds)
        Return ds
    End Function
End Class

in the DataAccessLayer class, i thought using byref or byvalue doesn't make
a difference since the parameter is a reference variable. am i nuts?

thanks,
ari

Ari:

When a reference variable is passed, either ByVal or ByRef, its
components can be modified. In your example, the properties of DataSet1
can be modified, no matter how 'ds' is passed.

But, when passed ByVal, 'ds' itself will not be changed. For that you
must pass 'ds'ByRef.

Show quote Hide quote ByRef means that any changes to the underlying variable you are passing into
the function will be visible when the function exists. ByVal in turn means
any such changes are discarded. The key is to understanding exactly what it
is you are passing in as a parameter.


In this case, you are passing in a reference value - that is, a pointer to
an  object on the heap. If you pass it in ByRef, the specific instance of
the object type that the pointer is referencing can be changed when the
function exits. If you pass it in ByVal however, any such changes are
discarded. Either way, any changes to the instance of the object itself are
visible after the function exits.


Consider a simple example:


'--------------------------------------------------------
Public Class TestClass
  Public n As Integer = 0
End Class


Public Module [module]
  Private Sub SubOne(ByRef TCls As TestClass)
    TCls = New TestClass
    TCls.n = 10
  End Sub

  Private Sub SubTwo(ByVal TCls As TestClass)
    TCls = New TestClass
    TCls.n = 10
  End Sub

  Public Sub Main()
    Dim TClsOne As TestClass
    Dim TClsTwo As TestClass

    TClsOne = New TestClass
    TClsTwo = TClsOne
    TClsOne.n = 1

    Console.WriteLine("Original object values: ")
    Console.WriteLine("TClsOne: " & TClsOne.n)
    Console.WriteLine("TClsTwo: " & TClsTwo.n)
    Console.WriteLine

    SubOne(TClsOne)
    SubTwo(TClsTwo)
    Console.WriteLine("Object values after calling subs: ")
    Console.WriteLine("TClsOne: " & TClsOne.n)
    Console.WriteLine("TClsTwo: " & TClsTwo.n)

  End Sub

End Module
'--------------------------------------------------------



Here we have a simple class with a single Public Integer member. Our module
in turn creates two references to the same object:


'--------------------------------------------------------
    Dim TClsOne As TestClass
    Dim TClsTwo As TestClass

    TClsOne = New TestClass
    TClsTwo = TClsOne
    TClsOne.n = 1
'--------------------------------------------------------


While we've defined two object references, we actually only create a single
instance of the object. Both references variables TClsOne and TClsTwo in
fact point to the same instance of the TestClass object. A change to the
member variable 'n' by the first reference is therefore reflected in the 2nd
reference. When we output the first section we see the following:


'--------------------------------------------------------
    Original object values:
    TClsOne: 1
    TClsTwo: 1
'--------------------------------------------------------


Note that the change to the value of TClsOne.n is seen in the reference to
TClsTwo.n - again these two reference variable are pointing to the same
object instance in memory.


Now let's consider what is happening when we call our two subs (which differ
only by the fact that one parameter is passed in ByRef and the other is
passed in ByVal):


'--------------------------------------------------------
  Private Sub SubOne(ByRef TCls As TestClass)
    TCls = New TestClass
    TCls.n = 10
  End Sub

  Private Sub SubTwo(ByVal TCls As TestClass)
    TCls = New TestClass
    TCls.n = 10
  End Sub

  [...]
    SubOne(TClsOne)
    SubTwo(TClsTwo)
  [...]
'--------------------------------------------------------


In both cases a brand new instance of the TestClass object is create on the
heap and the reference variable is changed to point to it. We then change
the value of 'n' for that new object and exit. However, when we print out
the second output section, we see a different result:



'--------------------------------------------------------
    Object values after calling subs:
    TClsOne: 10
    TClsTwo: 1
'--------------------------------------------------------


Note that now the value of TClsOne.n is set to '10' whereas the value of
TClsTwo.n remains '1'. This is because in SubOne(), the TCls parameter is
passed in ByRef. Therefore, when we created the new TestClass object inside
the sub and set the TCls variable to point to it, that assignment remained
in place when the sub exited. At that point, TClsOne is pointing to the 2nd
instance of the TestClass object while TClsTwo is still pointing to the
original reference.


When we call SubTwo, the same steps occur inside the procedure. This time
however, the new reference is discarded when SubTwo exits and TClsTwo
therefore still points to the original object instance that it did prior to
calling the sub.


To summarize, the ByRef/ByVal keywords are relevant to both Value types and
Reference types. In the case of the Reference type, what you are passing in
is a pointer to an object (hence the term 'Reference' type). If you change
the instance that the parameter is pointing to, that reassignment is
retained when the Sub/Function exits if the parameter is passed in ByRef and
discarded if the parameter is passed in ByVal.


HTH.


Ralf

Ari,

Did you know that this code gives the same effect


          dim ds as New DataSet1
          Return  Me.SqlDataAdapter1.Fill(ds)
     Public Function GetCustomers() As DataSet1
        Dim dal As New DataAccessLayer
        dim ds as DataSet1 = dal.GetDataSet1()
     End Function
I find this much nicer, a call in a Sub in a seperated class confuse me
forever, than still have to see what happens there with that given dataset.

Keep in mind that you are only passing references.

Just my thought,

Cor

Show quote Hide quote http://groups.google.com/group/microsoft.public.dotnet.languages.vb/msg/41e83beb9988aabf


Armin

With objects:

ByRef allows the subroutine to actually change the object that <ds>  points
to. Remember variables are NOT "objects"... they are references to objects
(that exist somewhere in la la land).

ByVal does not allow the subroutine to change what <ds> points to. If it
tries to changes the reference (ds = New Dataset), the runtime steps in and
breaks the reference to the original <ds> so that the calling subroutine is
not affected.

Show quoteHide quote

wow, thanks for the awesome feedback. you guys are great.

Show quoteHide quote

Local Machine policy exceptions
VB.NET or C#.NET ???
Is there a difference between passing "" and passing Nothing to a Windows API ?
TCP/IP Socket communication from multiple clients
reading text files
Help to Italy
Open a text file and into an array ??
Must I change the property in 26 projects or is there a soultion level way of doing it
Usual Databinding Question - UNusual Requirements
HREF QUESTION (cross)