Dennis,
| It is obvious that that only a reference to the array object is stored in
| the structure and that is what is passed.
Yes! I believe that is what I stated.
| Of course the string wasn't
| changed since it's immutable (whatever that means).
You changed a reference to the string, you did not change the string.
Immutable means that the object itself is unchangeable (not modifiable).
--
Hope this helps
Jay [MVP - Outlook]
..NET Application Architect, Enthusiast, & Evangelist
T.S. Bradley -
http://www.tsbradley.net
"Dennis" <De****@discussions.microsoft.com> wrote in message
news:62**********************************@microsof t.com...
| Kevin,Jay - as a test, I did the following:
|
| 'In my Main Program
| Public Structure myStruct
| Public b As Byte()
| Public s As String
| End Structure
| Dim st As myStruct
| ReDim st.b(3)
| st.b(0) = 1 : st.b(1) = 2 : st.b(2) = 3
| st.s = "Original String"
| Something(st)
| 'Break here and check values of st which were, st.s=Original String,
| st.b(0)=25, st.b(1)=30, st.b(2)=35
|
| Private Sub Something(ByVal c() As Byte)
| st.s = "New String"
| st.b(0) = 25: st.b(1) = 30: st.b(2) = 35
| End Sub
|
| It is obvious that that only a reference to the array object is stored in
| the structure and that is what is passed. Of course the string wasn't
| changed since it's immutable (whatever that means).
| --
| Dennis in Houston
|
|
| "Jay B. Harlow [MVP - Outlook]" wrote:
|
| > Doh! typo
| >
| > | However the array that parameter.b references is the
| > | same array that local.b references, so changing an element of the
array
| > | "parameter.b(0) = 5" also changes "local.i".
| >
| > Should be:
| >
| > "parameter.b(0) = 5" also changes "local.b(0)".
| >
| > --
| > Hope this helps
| > Jay [MVP - Outlook]
| > ..NET Application Architect, Enthusiast, & Evangelist
| > T.S. Bradley -
http://www.tsbradley.net
| >
| >
| > "Jay B. Harlow [MVP - Outlook]" <Ja************@tsbradley.net> wrote in
| > message news:%2****************@TK2MSFTNGP14.phx.gbl...
| > | Kevin,
| > || E.g. if you pass myStructureDef to a method, you'll be passing a
copy,
| > | which
| > || includes a copy of the array and the string.
| > | As you stated, Arrays & Strings are reference types. The
myStructureDef
| > | structure contains a reference to the actual objects on the heap. Not
a
| > copy
| > | of the actual object!
| > |
| > | If you pass myStructureDef to a method you will be passing a copy of
the
| > | structure, which includes a copy of the *references* to the array &
the
| > | string objects. There will only be a single instance of the array &
| > string
| > | object on the heap!
| > |
| > | Because Strings are immutable its hard to notice a difference. However
| > | Arrays & most other reference types are mutable, consider the
following:
| > |
| > | Public Structure myStructureDef
| > | Public i As Integer
| > | Public b() As Byte
| > | Public t As String
| > | End Structure
| > |
| > | Private Sub Something(ByVal parameter As myStructureDef)
| > | parameter.i = 2
| > | parameter.b(0) = 5
| > | parameter.b(1) = 6
| > | parameter.b(2) = 7
| > | End Sub
| > |
| > | Dim local As myStructureDef
| > | local.b = New Byte() {1, 2, 3}
| > | local.t = "Hello"
| > | Something(local)
| > |
| > | "parameter" will be a copy of the "local" myStructureDef, parameter.i
is
| > | inline in the structure as its a value type, so changing parameter.i
does
| > | not change local.i. However the array that parameter.b references is
the
| > | same array that local.b references, so changing an element of the
array
| > | "parameter.b(0) = 5" also changes "local.i". However changing the
| > reference
| > | itself, will change the reference itself "parameter.b = New Byte() {4,
5,
| > | 6}" will create a new array object on the heap, replacing the
reference
| > that
| > | "parameter.b" is...
| > |
| > |
| > | --
| > | Hope this helps
| > | Jay [MVP - Outlook]
| > | .NET Application Architect, Enthusiast, & Evangelist
| > | T.S. Bradley -
http://www.tsbradley.net
| > |
| > |
| > | "Kevin Westhead" <ma***********@nospam.nospam> wrote in message
| > | news:uz**************@TK2MSFTNGP15.phx.gbl...
| > || Arrays and strings are both reference types, so they'll be allocated
on
| > | the
| > || GC heap. I think the 16 byte rule is just one guideline aimed at
getting
| > | you
| > || to consider whether you really want value type or reference type
| > | semantics.
| > || E.g. if you pass myStructureDef to a method, you'll be passing a
copy,
| > | which
| > || includes a copy of the array and the string. If you assign one
instance
| > to
| > || another, again you'll be assigning a copy rather than having both
| > | instances
| > || reference the same data. If you find yourself passing myStructureDef
| > || arguments ByRef alot then you should really consider using a
reference
| > | type
| > || instead. You should also think about how often myStructureDef will be
| > | boxed
| > || in your core scenarios.
| > ||
| > || --
| > || Kevin Westhead
| > ||
| > || "Dennis" <De****@discussions.microsoft.com> wrote in message
| > || news:15**********************************@microsof t.com...
| > || > If I have a structure like;
| > || >
| > || > Public Structure myStructureDef
| > || > Public b() as Byte
| > || > Public t as String
| > || > End Structure
| > || >
| > || > If I pass this structure, will the values in the array b be stored
on
| > | the
| > || > stack or will just a pointer to the array be stored on the stack?
I am
| > || > trying to decide whether to use Structures or Pointers. I know
that
| > || > M'soft
| > || > recommends to use a class if the length is over about 16 bytes but
does
| > || > this
| > || > include all the array elements or just pointers to the array?
| > || > --
| > || > Dennis in Houston
| > ||
| > ||
| > |
| > |
| >
| >
| >
