With Clause

[Chris, Master of All Things Insignificant]

I have come to greatly respect both Herfried & Cor's reponses and since the
two conflicted, I wanted to get some clarification.

My orginal post:
Herfried, maybe your example here can get you to answer a question I've
wondered about for a while.

With Me.Label1
.Text = ...
.Refresh()
End With

The idea behind the With clause is it allows for faster execution since
the "Me" ojbect doesn't have to be resolved 2 times in your example. But
you could rewrite your sample w/o the Me

With Label1
.Text = ...
.Refresh()
End With

In this case there wouldn't be any inhancement since you are not actually
eliminating the dot. Am I correct in my thinking?

Herfried's response
The 'Me.' is resolved even if it's not explicitly written. In this case I
used With type the code faster ;-).

Cor's Reposnse
The "Me" is only for the programmer, it does nothing at runtime.
The With clause creates an extra reference in a program. In this case it
will be slower than a program without a With clause, however think than
probably in parts of nanoseconds.
I hope this gives some ideas?

[Cor Ligthert]

Chris,

Here the IL code from this program (I had it already ready when Herfried
would react however he did not) ;-)

Public Sub test()
With Me.label1
.Text = "Me"
.Refresh()
End With
With label1
.Text = "without Me"
.Refresh()
End With
label1.Text = "without With"
label1.Refresh( )

End Sub
\\
IL_0000: ldarg.0
IL_0001: ldfld class
[System.Windows. Forms]System.Windows. Forms.Label Testje.Class1:: label1
IL_0006: stloc.1
IL_0007: ldloc.1
IL_0008: ldstr "Me"
IL_000d: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: set_Text(string )
IL_0012: ldloc.1
IL_0013: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: Refresh()
IL_0018: ldnull
IL_0019: stloc.1
IL_001a: ldarg.0
IL_001b: ldfld class
[System.Windows. Forms]System.Windows. Forms.Label Testje.Class1:: label1
IL_0020: stloc.0
IL_0021: ldloc.0
IL_0022: ldstr "without Me"
IL_0027: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: set_Text(string )
IL_002c: ldloc.0
IL_002d: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: Refresh()
IL_0032: ldnull
IL_0033: stloc.0
IL_0034: ldarg.0
IL_0035: ldfld class
[System.Windows. Forms]System.Windows. Forms.Label Testje.Class1:: label1
IL_003a: ldstr "without With"
IL_003f: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: set_Text(string )
IL_0044: ldarg.0
IL_0045: ldfld class
[System.Windows. Forms]System.Windows. Forms.Label Testje.Class1:: label1
IL_004a: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: Refresh()
IL_004f: ret
///

[Anand[MVP]]

But if you look at it another way, if you consider a access to a property as
multiple levels of indirection of a pointer, does'nt With make is faster by
removing a few levels of indirection?

Rgds,
Anand M
http://www.dotnetindia.com

"Chris, Master of All Things Insignifican" wrote:

I have come to greatly respect both Herfried & Cor's reponses and since the
two conflicted, I wanted to get some clarification.

My orginal post:
Herfried, maybe your example here can get you to answer a question I've
wondered about for a while.

With Me.Label1
.Text = ...
.Refresh()
End With

The idea behind the With clause is it allows for faster execution since
the "Me" ojbect doesn't have to be resolved 2 times in your example. But
you could rewrite your sample w/o the Me

With Label1
.Text = ...
.Refresh()
End With

In this case there wouldn't be any inhancement since you are not actually
eliminating the dot. Am I correct in my thinking?

Herfried's response
The 'Me.' is resolved even if it's not explicitly written. In this case I
used With type the code faster ;-).

Cor's Reposnse
The "Me" is only for the programmer, it does nothing at runtime.
The With clause creates an extra reference in a program. In this case it
will be slower than a program without a With clause, however think than
probably in parts of nanoseconds.
I hope this gives some ideas?

[Chris, Master of All Things Insignificant]

Thanks, you just proved that I was thinking correctly.

Chris

"Cor Ligthert" <no************ @planet.nl> wrote in message
news:up******** ******@TK2MSFTN GP12.phx.gbl...

Chris,

Here the IL code from this program (I had it already ready when Herfried
would react however he did not) ;-)

Public Sub test()
With Me.label1
.Text = "Me"
.Refresh()
End With
With label1
.Text = "without Me"
.Refresh()
End With
label1.Text = "without With"
label1.Refresh( )

End Sub
\\
IL_0000: ldarg.0
IL_0001: ldfld class
[System.Windows. Forms]System.Windows. Forms.Label Testje.Class1:: label1
IL_0006: stloc.1
IL_0007: ldloc.1
IL_0008: ldstr "Me"
IL_000d: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: set_Text(string )
IL_0012: ldloc.1
IL_0013: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: Refresh()
IL_0018: ldnull
IL_0019: stloc.1
IL_001a: ldarg.0
IL_001b: ldfld class
[System.Windows. Forms]System.Windows. Forms.Label Testje.Class1:: label1
IL_0020: stloc.0
IL_0021: ldloc.0
IL_0022: ldstr "without Me"
IL_0027: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: set_Text(string )
IL_002c: ldloc.0
IL_002d: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: Refresh()
IL_0032: ldnull
IL_0033: stloc.0
IL_0034: ldarg.0
IL_0035: ldfld class
[System.Windows. Forms]System.Windows. Forms.Label Testje.Class1:: label1
IL_003a: ldstr "without With"
IL_003f: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: set_Text(string )
IL_0044: ldarg.0
IL_0045: ldfld class
[System.Windows. Forms]System.Windows. Forms.Label Testje.Class1:: label1
IL_004a: callvirt instance void
[System.Windows. Forms]System.Windows. Forms.Control:: Refresh()
IL_004f: ret
///

[Samuel R. Neff]

In the particular example, the With is not providing a benefit because
the target variable is immediately available.

With Me.Label1
.Text = ...
.Refresh()
End With

Is the same as

Dim lbl as Label = Me.Label1
lbl.Text = ...
lbl.Refresh()

which mostly likely a detraction given the extra variable allocation
and assignment. However, if the With was more complex, such as

With Me.SomeObject.N estedObject.Sub NestedObject.An dFurther
.Something ...
.SomethignElse. ..
.AndThirdThing. ..
End With

Then it can provide a benefit as the long list of evaluations is not
performed many times.

Sam
On Thu, 9 Dec 2004 08:43:45 -0800, "Anand[MVP]"
<An******@discu ssions.microsof t.com> wrote:

But if you look at it another way, if you consider a access to a property as
multiple levels of indirection of a pointer, does'nt With make is faster by
removing a few levels of indirection?

Rgds,
Anand M
http://www.dotnetindia.com

[David Browne]

"Chris, Master of All Things Insignificant" <chris@No_Spam_ Please.com> wrote
in message news:e%******** ********@TK2MSF TNGP12.phx.gbl. ..

I have come to greatly respect both Herfried & Cor's reponses and since
the two conflicted, I wanted to get some clarification.

My orginal post:
Herfried, maybe your example here can get you to answer a question I've
wondered about for a while.

With Me.Label1
.Text = ...
.Refresh()
End With

The idea behind the With clause is it allows for faster execution since
the "Me" ojbect doesn't have to be resolved 2 times in your example. But
you could rewrite your sample w/o the Me

With Label1
.Text = ...
.Refresh()
End With

In this case there wouldn't be any inhancement since you are not actually
eliminating the dot. Am I correct in my thinking?

Herfried's response
The 'Me.' is resolved even if it's not explicitly written. In this case I
used With type the code faster ;-).

Cor's Reposnse
The "Me" is only for the programmer, it does nothing at runtime.
The With clause creates an extra reference in a program. In this case it
will be slower than a program without a With clause, however think than
probably in parts of nanoseconds.
I hope this gives some ideas?

There's no disagreement. WITH is for programmer convenience only. It
introduces an additional local variable, and so it's certianly not faster.

Your notion that WITH helps with performance by reducting object resolutions
is obsolete. This was true when using VBScript and late-bound VB6, but not
in early-bound VB6 and not in VB.NET. These are compiled languages, and
objects references are fixed at compile-time.

BTW WITH still can reduce the number of reflection calls in late-bound
VB.NET, but you shouldn't be using late-bound VB.NET much, so it doesn't
count.

David

[Jay B. Harlow [MVP - Outlook]]

Chris,
They are both correct, its really a matter of perspective. Is the class half
full or is it really half empty?

If you leave Me off it is implicitly included.

However Me itself does not generate any code per se, Me is used by the
compiler to resolve identifiers. If you include Me the identifier is
resolved to the current object (ignoring local variables & parameters), if
you exclude Me the compiler resolves the identifier to the current scope,
which include locals variables & parameters. By current object I mean the
current class & any base classes.

The IL to access members of the current object is going to be the same
whether Me was included or not (which is what Cor showed).

IMHO: What matters more is the use of Me (implicitly or explicitly) verses
MyBase verses MyClass. As each has a specific context that the compiler uses
to search for members...

The With clause creates an extra reference in a program. In this case it
will be slower than a program without a With clause, however think than
probably in parts of nanoseconds. Are you quoting Cor correctly? With will normally increases not decreases
speed. Yes it creates a temporary variable, but that shouldn't really
matter.

A better example might be (within Form1)

Dim dialog As New Form2
With dialog.Label1
.Text = ...
.Refresh()
End With

Here dialog.Label1 is resolved once, then that temporary reference is used
to call .Text & .Refresh. Where as

dialog.Label1.T ext = ...
dialog.Label1.R efresh()

Requires dialog.Label1 to be resolved twice, if you have 10 or more
statements inside the With & the with is in a loop, this can start adding up
quickly...

Hope this helps
Jay

"Chris, Master of All Things Insignificant" <chris@No_Spam_ Please.com> wrote
in message news:e%******** ********@TK2MSF TNGP12.phx.gbl. ..I have come to greatly respect both Herfried & Cor's reponses and since
the two conflicted, I wanted to get some clarification.

My orginal post:
Herfried, maybe your example here can get you to answer a question I've
wondered about for a while.

With Me.Label1
.Text = ...
.Refresh()
End With

The idea behind the With clause is it allows for faster execution since
the "Me" ojbect doesn't have to be resolved 2 times in your example. But
you could rewrite your sample w/o the Me

With Label1
.Text = ...
.Refresh()
End With

In this case there wouldn't be any inhancement since you are not actually
eliminating the dot. Am I correct in my thinking?

Herfried's response
The 'Me.' is resolved even if it's not explicitly written. In this case I
used With type the code faster ;-).

Cor's Reposnse
The "Me" is only for the programmer, it does nothing at runtime.
The With clause creates an extra reference in a program. In this case it
will be slower than a program without a With clause, however think than
probably in parts of nanoseconds.
I hope this gives some ideas?

[Cor Ligthert]

Samuel,

However it is the same as
dim mypointerwith as object =
Me.SomeObject.N estedObject.Sub NestedObject.An dFurther
mypointerwith.s omething
mypointerwiht.s omethingelse
mypointerwith.a ndthirdthing

Not using a property is as well faster than using it, however that cannot be
a reason to avoid it.

That I say because what is saved is less than will ever be gained because
of the way most programs are used.

When those things become really important than you would start thinking in
not using C# or DotNet in my opinion. This is about parts of nanoseconds.

For me is readability more important, and than it becomes maybe a matter of
taste.
I don't like the "with" you see them mostly used by VB classic diehards.

Just my thought,

Cor

[Cor Ligthert]

Jay,

The With clause creates an extra reference in a program. In this case it
will be slower than a program without a With clause, however think than
probably in parts of nanoseconds.

Are you quoting Cor correctly? With will normally increases not decreases
speed. Yes it creates a temporary variable, but that shouldn't really
matter.

Yes Chris is, look at "In this case", see for the rest as Samuel wrote and
my reply on that.

Cor

[Jay B. Harlow [MVP - Outlook]]

David,

Your notion that WITH helps with performance by reducting object
resolutions is obsolete.
Which is largely a myth!

It would be interesting to look at the IL for Samuel's suggestion:

Class base
Public class1 As class1
End Class

Class class1
Public class2 As class2
End Class

Class class2
Public class3 As class3
End Class

Class class3
Public class4 As class4
End Class

Class class4
Public class5 As class5
End Class

Class class5
Public value1 As Integer
Public value2 As Integer
Public value3 As Integer
End Class

Public Sub TestWith()
Dim a As base
With a.class1.class2 .class3.class4. class5
.value1 = 1
.value2 = 2
.value3 = 3
End With
End Sub

Public Sub TestWithout()
Dim a As base
a.class1.class2 .class3.class4. class5.value1 = 1
a.class1.class2 .class3.class4. class5.value2 = 2
a.class1.class2 .class3.class4. class5.value3 = 3
End Sub

Now check out the IL for the above two methods (release build under VS.NET
2003)

..method public instance void TestWith() cil managed
{
// Code size 51 (0x33)
.maxstack 2
.locals init (class XSLT.Sample.Mai nForm/base V_0,
class XSLT.Sample.Mai nForm/class5 V_1)
IL_0000: ldloc.0
IL_0001: ldfld class XSLT.Sample.Mai nForm/class1
XSLT.Sample.Mai nForm/base::class1
IL_0006: ldfld class XSLT.Sample.Mai nForm/class2
XSLT.Sample.Mai nForm/class1::class2
IL_000b: ldfld class XSLT.Sample.Mai nForm/class3
XSLT.Sample.Mai nForm/class2::class3
IL_0010: ldfld class XSLT.Sample.Mai nForm/class4
XSLT.Sample.Mai nForm/class3::class4
IL_0015: ldfld class XSLT.Sample.Mai nForm/class5
XSLT.Sample.Mai nForm/class4::class5
IL_001a: stloc.1
IL_001b: ldloc.1
IL_001c: ldc.i4.1
IL_001d: stfld int32 XSLT.Sample.Mai nForm/class5::value1
IL_0022: ldloc.1
IL_0023: ldc.i4.2
IL_0024: stfld int32 XSLT.Sample.Mai nForm/class5::value2
IL_0029: ldloc.1
IL_002a: ldc.i4.3
IL_002b: stfld int32 XSLT.Sample.Mai nForm/class5::value3
IL_0030: ldnull
IL_0031: stloc.1
IL_0032: ret
} // end of method MainForm::TestW ith

..method public instance void TestWithout() cil managed
{
// Code size 97 (0x61)
.maxstack 2
.locals init (class XSLT.Sample.Mai nForm/base V_0)
IL_0000: ldloc.0
IL_0001: ldfld class XSLT.Sample.Mai nForm/class1
XSLT.Sample.Mai nForm/base::class1
IL_0006: ldfld class XSLT.Sample.Mai nForm/class2
XSLT.Sample.Mai nForm/class1::class2
IL_000b: ldfld class XSLT.Sample.Mai nForm/class3
XSLT.Sample.Mai nForm/class2::class3
IL_0010: ldfld class XSLT.Sample.Mai nForm/class4
XSLT.Sample.Mai nForm/class3::class4
IL_0015: ldfld class XSLT.Sample.Mai nForm/class5
XSLT.Sample.Mai nForm/class4::class5
IL_001a: ldc.i4.1
IL_001b: stfld int32 XSLT.Sample.Mai nForm/class5::value1
IL_0020: ldloc.0
IL_0021: ldfld class XSLT.Sample.Mai nForm/class1
XSLT.Sample.Mai nForm/base::class1
IL_0026: ldfld class XSLT.Sample.Mai nForm/class2
XSLT.Sample.Mai nForm/class1::class2
IL_002b: ldfld class XSLT.Sample.Mai nForm/class3
XSLT.Sample.Mai nForm/class2::class3
IL_0030: ldfld class XSLT.Sample.Mai nForm/class4
XSLT.Sample.Mai nForm/class3::class4
IL_0035: ldfld class XSLT.Sample.Mai nForm/class5
XSLT.Sample.Mai nForm/class4::class5
IL_003a: ldc.i4.2
IL_003b: stfld int32 XSLT.Sample.Mai nForm/class5::value2
IL_0040: ldloc.0
IL_0041: ldfld class XSLT.Sample.Mai nForm/class1
XSLT.Sample.Mai nForm/base::class1
IL_0046: ldfld class XSLT.Sample.Mai nForm/class2
XSLT.Sample.Mai nForm/class1::class2
IL_004b: ldfld class XSLT.Sample.Mai nForm/class3
XSLT.Sample.Mai nForm/class2::class3
IL_0050: ldfld class XSLT.Sample.Mai nForm/class4
XSLT.Sample.Mai nForm/class3::class4
IL_0055: ldfld class XSLT.Sample.Mai nForm/class5
XSLT.Sample.Mai nForm/class4::class5
IL_005a: ldc.i4.3
IL_005b: stfld int32 XSLT.Sample.Mai nForm/class5::value3
IL_0060: ret
} // end of method MainForm::TestW ithout

Notice that TestWith resolves a.class1.class2 .class3.class4. class5 once as
you stated, while TestWithout resolves it 3 times. Also notice that
TestWithout is almost twice as large (code size 97 verses 51)

I have not, but it might be interesting to look at what the JIT compiler
generates for the above. It might also be interesting to profile (time)
TestWith & TestWithout...

Granted I rarely use "a.class1.class 2.class3.class4 .class5" in real code and
most of my With statements wind up being methods on the target object, its
still nice to see what is really going on.

Hope this helps
Jay

"David Browne" <davidbaxterbro wne no potted me**@hotmail.co m> wrote in
message news:Ob******** ******@tk2msftn gp13.phx.gbl...
"Chris, Master of All Things Insignificant" <chris@No_Spam_ Please.com>
wrote in message news:e%******** ********@TK2MSF TNGP12.phx.gbl. ..

I have come to greatly respect both Herfried & Cor's reponses and since
the two conflicted, I wanted to get some clarification.

My orginal post:
Herfried, maybe your example here can get you to answer a question I've
wondered about for a while.

With Me.Label1
.Text = ...
.Refresh()
End With

The idea behind the With clause is it allows for faster execution since
the "Me" ojbect doesn't have to be resolved 2 times in your example. But
you could rewrite your sample w/o the Me

With Label1
.Text = ...
.Refresh()
End With

In this case there wouldn't be any inhancement since you are not actually
eliminating the dot. Am I correct in my thinking?

Herfried's response
The 'Me.' is resolved even if it's not explicitly written. In this case
I
used With type the code faster ;-).

Cor's Reposnse
The "Me" is only for the programmer, it does nothing at runtime.
The With clause creates an extra reference in a program. In this case it
will be slower than a program without a With clause, however think than
probably in parts of nanoseconds.
I hope this gives some ideas?

There's no disagreement. WITH is for programmer convenience only. It
introduces an additional local variable, and so it's certianly not faster.

Your notion that WITH helps with performance by reducting object
resolutions is obsolete. This was true when using VBScript and late-bound
VB6, but not in early-bound VB6 and not in VB.NET. These are compiled
languages, and objects references are fixed at compile-time.

BTW WITH still can reduce the number of reflection calls in late-bound
VB.NET, but you shouldn't be using late-bound VB.NET much, so it doesn't
count.

David