A
Abdul Shakeel
Can anyone defien me the differnce between
[Forms].[frm1]
and
[Forms]![frm1]
when we use a "." and when "!"
[Forms].[frm1]
and
[Forms]![frm1]
when we use a "." and when "!"
You are using an out of date browser. It may not display this or other websites correctly.
You should upgrade or use an alternative browser.
You should upgrade or use an alternative browser.
S
Steve Schapel
Abdul,
AFAIK no-one says this better than Dirk Goldgar, as follows...
--------------------------------------
"It's not so much a question of one or the other being "proper syntax",
but that they mean different things that nevertheless almost always give
the same result. As I understand it, the bang (!) notation specifically
denotes that what follows is a member of a collection; in this case, a
member of the form object's default collection, the Controls collection.
The dot (.) notation denotes that what follows is a property or method
of the preceding object. That would logically make the bang notation
"proper" and the dot notation improper.
But wait. Wherever possible, Access makes the controls on a form and
the fields in its recordsource all available as properties of the form.
It also makes the fields of the recordsource available via the bang
notation. I'm not sure exactly how it does this; maybe if a name is
not found in the Controls collection it checks the Fields collection of
the form's recordset as a fallback position. So for most practical
purposes Me!ControlName and Me.ControlName evaluate to the same thing,
and the timing tests I've seen suggest that there is little to choose
between them as far as execution efficiency is concerned. I seem to
recall that there is a very slight difference, but I can't remember
which way the advantage lies, and it's not much. There's a coding-time
advantage, however, to using the dot notation, as it makes the
"intellisense" dropdown lists available. That's a strong argument for
using the dot notation, in my book.
But wait again! I said above that Access makes the controls available
as properties "wherever possible". There are cases where it can't do
that. Specifically, it can't do it when there is already a property of
the same name as the control in question. For example, if your form
"Form1" has a control or a field foolishly named "Name", currently
displaying the value "Ken Snell", then executing this statement in the
form's code module:
Debug.Print Me!Name, Me.Name
will print
Ken Snell Form1
in the Immediate Window. So you must be careful not to use any reserved
words or built-in properties as names for your controls, if you want to
use the dot notation to refer to them. But then, you should avoid doing
that anyway, as it tends in general to confuse poor Access.
AFAIK no-one says this better than Dirk Goldgar, as follows...
--------------------------------------
"It's not so much a question of one or the other being "proper syntax",
but that they mean different things that nevertheless almost always give
the same result. As I understand it, the bang (!) notation specifically
denotes that what follows is a member of a collection; in this case, a
member of the form object's default collection, the Controls collection.
The dot (.) notation denotes that what follows is a property or method
of the preceding object. That would logically make the bang notation
"proper" and the dot notation improper.
But wait. Wherever possible, Access makes the controls on a form and
the fields in its recordsource all available as properties of the form.
It also makes the fields of the recordsource available via the bang
notation. I'm not sure exactly how it does this; maybe if a name is
not found in the Controls collection it checks the Fields collection of
the form's recordset as a fallback position. So for most practical
purposes Me!ControlName and Me.ControlName evaluate to the same thing,
and the timing tests I've seen suggest that there is little to choose
between them as far as execution efficiency is concerned. I seem to
recall that there is a very slight difference, but I can't remember
which way the advantage lies, and it's not much. There's a coding-time
advantage, however, to using the dot notation, as it makes the
"intellisense" dropdown lists available. That's a strong argument for
using the dot notation, in my book.
But wait again! I said above that Access makes the controls available
as properties "wherever possible". There are cases where it can't do
that. Specifically, it can't do it when there is already a property of
the same name as the control in question. For example, if your form
"Form1" has a control or a field foolishly named "Name", currently
displaying the value "Ken Snell", then executing this statement in the
form's code module:
Debug.Print Me!Name, Me.Name
will print
Ken Snell Form1
in the Immediate Window. So you must be careful not to use any reserved
words or built-in properties as names for your controls, if you want to
use the dot notation to refer to them. But then, you should avoid doing
that anyway, as it tends in general to confuse poor Access.
P
Pieter Wijnen
A little comment:
dot notation is slightly faster than bang, as Access does not have to
iterrate through the whole controls collection. Also
Using the dot notation will lead to a compile error if a control is
non-existant (renamed /deleted), whereas bang notation will "only" lead to a
runtime error.
Pieter
dot notation is slightly faster than bang, as Access does not have to
iterrate through the whole controls collection. Also
Using the dot notation will lead to a compile error if a control is
non-existant (renamed /deleted), whereas bang notation will "only" lead to a
runtime error.
Pieter
Steve Schapel said:Abdul,
AFAIK no-one says this better than Dirk Goldgar, as follows...
--------------------------------------
"It's not so much a question of one or the other being "proper syntax",
but that they mean different things that nevertheless almost always give
the same result. As I understand it, the bang (!) notation specifically
denotes that what follows is a member of a collection; in this case, a
member of the form object's default collection, the Controls collection.
The dot (.) notation denotes that what follows is a property or method of
the preceding object. That would logically make the bang notation "proper"
and the dot notation improper.
But wait. Wherever possible, Access makes the controls on a form and the
fields in its recordsource all available as properties of the form. It
also makes the fields of the recordsource available via the bang notation.
I'm not sure exactly how it does this; maybe if a name is not found in
the Controls collection it checks the Fields collection of the form's
recordset as a fallback position. So for most practical purposes
Me!ControlName and Me.ControlName evaluate to the same thing, and the
timing tests I've seen suggest that there is little to choose between them
as far as execution efficiency is concerned. I seem to recall that there
is a very slight difference, but I can't remember which way the advantage
lies, and it's not much. There's a coding-time advantage, however, to
using the dot notation, as it makes the "intellisense" dropdown lists
available. That's a strong argument for using the dot notation, in my
book.
But wait again! I said above that Access makes the controls available as
properties "wherever possible". There are cases where it can't do that.
Specifically, it can't do it when there is already a property of the same
name as the control in question. For example, if your form "Form1" has a
control or a field foolishly named "Name", currently
displaying the value "Ken Snell", then executing this statement in the
form's code module:
Debug.Print Me!Name, Me.Name
will print
Ken Snell Form1
in the Immediate Window. So you must be careful not to use any reserved
words or built-in properties as names for your controls, if you want to
use the dot notation to refer to them. But then, you should avoid doing
that anyway, as it tends in general to confuse poor Access.
-------------------------------
--
Steve Schapel, Microsoft Access MVP
Abdul said:Can anyone defien me the differnce between [Forms].[frm1]
and
[Forms]![frm1]
when we use a "." and when "!"