Des années que je travaille sur cette base:
Depuis ce matin, certains formulaires ou états de mon application
n'acceptent plus la syntaxe "Me.[MonChamp]", et je suis obligé de remplacer
le point par un point d'exclamation: "Me![MonChamp]".
Le problème, c'est que mon application est énorme et que je ne peux pas
m'amuser à changer les itérations par la méthode <Ctrl>+H
La grande question:
Pourquoi ce problème depuis aujourd'hui ?
Pourquoi seulement sur certains éléments de ma base ?
Est-ce un problème de références VBA ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
J-Pierre
Bonjour Fred,
Ta base est fatiguée ? début de corruption ? Tout importer dans une base vierge ? Si tu as des formulaires avec beaucoup de code VBA (je parle de 1500/2000 lignes) , parfois, Access bouffe une partie du code......
En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de syntaxe ne sont détectées qu'à l'exécution, alors qu'avec "Me.[MonChamp]", c'est détecté à la compilation.
J-Pierre
"Fred" a écrit dans le message de news: 4492a017$0$1019$
Du forum, bonjour,
Des années que je travaille sur cette base: Depuis ce matin, certains formulaires ou états de mon application n'acceptent plus la syntaxe "Me.[MonChamp]", et je suis obligé de remplacer le point par un point d'exclamation: "Me![MonChamp]". Le problème, c'est que mon application est énorme et que je ne peux pas m'amuser à changer les itérations par la méthode <Ctrl>+H
La grande question: Pourquoi ce problème depuis aujourd'hui ? Pourquoi seulement sur certains éléments de ma base ? Est-ce un problème de références VBA ?
Merci d'avance à ceux qui peuvent m'aider.
Fred
Bonjour Fred,
Ta base est fatiguée ? début de corruption ? Tout importer dans une base vierge ? Si tu as des formulaires avec beaucoup de code VBA
(je parle de 1500/2000 lignes) , parfois, Access bouffe une partie du code......
En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de syntaxe ne sont détectées qu'à l'exécution, alors qu'avec
"Me.[MonChamp]", c'est détecté à la compilation.
J-Pierre
"Fred" <fred@memorys.fr> a écrit dans le message de news: 4492a017$0$1019$ba4acef3@news.orange.fr...
Du forum, bonjour,
Des années que je travaille sur cette base:
Depuis ce matin, certains formulaires ou états de mon application n'acceptent plus la syntaxe "Me.[MonChamp]", et je suis obligé
de remplacer le point par un point d'exclamation: "Me![MonChamp]".
Le problème, c'est que mon application est énorme et que je ne peux pas m'amuser à changer les itérations par la méthode <Ctrl>+H
La grande question:
Pourquoi ce problème depuis aujourd'hui ?
Pourquoi seulement sur certains éléments de ma base ?
Est-ce un problème de références VBA ?
Ta base est fatiguée ? début de corruption ? Tout importer dans une base vierge ? Si tu as des formulaires avec beaucoup de code VBA (je parle de 1500/2000 lignes) , parfois, Access bouffe une partie du code......
En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de syntaxe ne sont détectées qu'à l'exécution, alors qu'avec "Me.[MonChamp]", c'est détecté à la compilation.
J-Pierre
"Fred" a écrit dans le message de news: 4492a017$0$1019$
Du forum, bonjour,
Des années que je travaille sur cette base: Depuis ce matin, certains formulaires ou états de mon application n'acceptent plus la syntaxe "Me.[MonChamp]", et je suis obligé de remplacer le point par un point d'exclamation: "Me![MonChamp]". Le problème, c'est que mon application est énorme et que je ne peux pas m'amuser à changer les itérations par la méthode <Ctrl>+H
La grande question: Pourquoi ce problème depuis aujourd'hui ? Pourquoi seulement sur certains éléments de ma base ? Est-ce un problème de références VBA ?
Merci d'avance à ceux qui peuvent m'aider.
Fred
3stone
Salut,
"J-Pierre" [...] | En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de syntaxe ne sont détectées qu'à l'exécution, alors qu'avec | "Me.[MonChamp]", c'est détecté à la compilation.
"très mauvais" ?? ;-)
Ci dessous un vieux post que j'ai déterré (Mishel Walsh ;-)
Personnellement, j'ajouterai que pour ceux qui utilise le "prémaché" d'Access, il est plus prudent d'utiliser le point "." pour se référer à un champ (de la source) mais d'utiliser un point d'exclamation "!" pour se référer à une zone de texte (un 'controle')
Le fait que l'erreur de syntaxe ne soit détectée qu'à l'exécution, n'est qu'un (léger) inconvénient en rapport des problèmes que peut apporter le fait que les zones de texte possèdent "par défaut" le même nom que leur source !!
Ceci n'est que mon avis (mais qui compte beaucoup pour moi ;-))
-------------------------------------------------------------------------------------- --- juillet 2002 --- Michel Walsh -------------------------------------------------------------------------------------- Le point refère à une propriété ou à une méthode. Me.NomDeContrôle refère au nom du contrôle en voyant le formulaire comme une classe qui expose le contrôle comme propriété (ou sous classe).
Le ! est un barbarisme qui est à utiliser lorsque les deux conditions suivantes sont remplies: - on réfère à un élément d'une collection - la collection à laquelle on réfère est une collection "par défaut"
Un simple exemple éclaircit le point:
rst.Fields("toto")
versus
rst!toto
On ne peut évidemment pas utiliser le point:
rs.toto
car un recordset ADO ou DAO n'expose PAS toto comme propriété, ou comme méthode, alors qu'un formulaire Access expose ses contrôles et la syntaxe OOP, ou de classe, Me.NomDeControle, est alors permise, en plus de la syntaxe de collection par défaut, Me!NomDeControle. -----------------------------------------------------------------
A+ Pierre (3stone) Access MVP Perso: http://www.3stone.be/ Conseils MPFA: http://www.mpfa.info/
Salut,
"J-Pierre"
[...]
| En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de syntaxe ne sont détectées qu'à
l'exécution, alors qu'avec
| "Me.[MonChamp]", c'est détecté à la compilation.
"très mauvais" ?? ;-)
Ci dessous un vieux post que j'ai déterré (Mishel Walsh ;-)
Personnellement, j'ajouterai que pour ceux qui utilise le "prémaché" d'Access,
il est plus prudent d'utiliser le point "." pour se référer à un champ (de la source)
mais d'utiliser un point d'exclamation "!" pour se référer à une zone de texte (un 'controle')
Le fait que l'erreur de syntaxe ne soit détectée qu'à l'exécution, n'est qu'un (léger)
inconvénient en rapport des problèmes que peut apporter le fait que les zones
de texte possèdent "par défaut" le même nom que leur source !!
Ceci n'est que mon avis (mais qui compte beaucoup pour moi ;-))
--------------------------------------------------------------------------------------
--- juillet 2002 --- Michel Walsh
--------------------------------------------------------------------------------------
Le point refère à une propriété ou à une méthode. Me.NomDeContrôle refère au nom du contrôle en
voyant le formulaire comme une classe qui expose le contrôle comme propriété (ou sous classe).
Le ! est un barbarisme qui est à utiliser lorsque les deux conditions suivantes sont remplies:
- on réfère à un élément d'une collection
- la collection à laquelle on réfère est une collection "par défaut"
Un simple exemple éclaircit le point:
rst.Fields("toto")
versus
rst!toto
On ne peut évidemment pas utiliser le point:
rs.toto
car un recordset ADO ou DAO n'expose PAS toto comme propriété, ou comme méthode, alors qu'un
formulaire Access expose ses contrôles et la syntaxe OOP, ou de classe, Me.NomDeControle, est
alors permise, en plus de la syntaxe de collection par défaut, Me!NomDeControle.
-----------------------------------------------------------------
A+
Pierre (3stone) Access MVP
Perso: http://www.3stone.be/
Conseils MPFA: http://www.mpfa.info/
"J-Pierre" [...] | En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de syntaxe ne sont détectées qu'à l'exécution, alors qu'avec | "Me.[MonChamp]", c'est détecté à la compilation.
"très mauvais" ?? ;-)
Ci dessous un vieux post que j'ai déterré (Mishel Walsh ;-)
Personnellement, j'ajouterai que pour ceux qui utilise le "prémaché" d'Access, il est plus prudent d'utiliser le point "." pour se référer à un champ (de la source) mais d'utiliser un point d'exclamation "!" pour se référer à une zone de texte (un 'controle')
Le fait que l'erreur de syntaxe ne soit détectée qu'à l'exécution, n'est qu'un (léger) inconvénient en rapport des problèmes que peut apporter le fait que les zones de texte possèdent "par défaut" le même nom que leur source !!
Ceci n'est que mon avis (mais qui compte beaucoup pour moi ;-))
-------------------------------------------------------------------------------------- --- juillet 2002 --- Michel Walsh -------------------------------------------------------------------------------------- Le point refère à une propriété ou à une méthode. Me.NomDeContrôle refère au nom du contrôle en voyant le formulaire comme une classe qui expose le contrôle comme propriété (ou sous classe).
Le ! est un barbarisme qui est à utiliser lorsque les deux conditions suivantes sont remplies: - on réfère à un élément d'une collection - la collection à laquelle on réfère est une collection "par défaut"
Un simple exemple éclaircit le point:
rst.Fields("toto")
versus
rst!toto
On ne peut évidemment pas utiliser le point:
rs.toto
car un recordset ADO ou DAO n'expose PAS toto comme propriété, ou comme méthode, alors qu'un formulaire Access expose ses contrôles et la syntaxe OOP, ou de classe, Me.NomDeControle, est alors permise, en plus de la syntaxe de collection par défaut, Me!NomDeControle. -----------------------------------------------------------------
A+ Pierre (3stone) Access MVP Perso: http://www.3stone.be/ Conseils MPFA: http://www.mpfa.info/
J-Pierre
Bonsoir Pierre,
Ca ne change rien à l'affaire, je préfère une erreur de compil à une erreur d'exécution :-) donc, très mauvais :-)
Même si Michel Walsh pense le contraire :-)
En plus, si tu relis sa phrase, elle ne veut rien dire. Je cite:
Personnellement, j'ajouterai que pour ceux qui utilise le "prémaché" d'Access, il est plus prudent d'utiliser le point "." pour se référer à un champ (de la source) mais d'utiliser un point d'exclamation "!" pour se référer à une zone de texte (un 'controle')
J-Pierre
PS: En fait, je m'en fous un peu, chacun utilise la méthode qu'il préfère :-)
"3stone" a écrit dans le message de news: %
Salut,
"J-Pierre" [...] | En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de syntaxe ne sont détectées qu'à l'exécution, alors qu'avec | "Me.[MonChamp]", c'est détecté à la compilation.
"très mauvais" ?? ;-)
Ci dessous un vieux post que j'ai déterré (Mishel Walsh ;-)
Personnellement, j'ajouterai que pour ceux qui utilise le "prémaché" d'Access, il est plus prudent d'utiliser le point "." pour se référer à un champ (de la source) mais d'utiliser un point d'exclamation "!" pour se référer à une zone de texte (un 'controle')
Le fait que l'erreur de syntaxe ne soit détectée qu'à l'exécution, n'est qu'un (léger) inconvénient en rapport des problèmes que peut apporter le fait que les zones de texte possèdent "par défaut" le même nom que leur source !!
Ceci n'est que mon avis (mais qui compte beaucoup pour moi ;-))
-------------------------------------------------------------------------------------- --- juillet 2002 --- Michel Walsh -------------------------------------------------------------------------------------- Le point refère à une propriété ou à une méthode. Me.NomDeContrôle refère au nom du contrôle en voyant le formulaire comme une classe qui expose le contrôle comme propriété (ou sous classe).
Le ! est un barbarisme qui est à utiliser lorsque les deux conditions suivantes sont remplies: - on réfère à un élément d'une collection - la collection à laquelle on réfère est une collection "par défaut"
Un simple exemple éclaircit le point:
rst.Fields("toto")
versus
rst!toto
On ne peut évidemment pas utiliser le point:
rs.toto
car un recordset ADO ou DAO n'expose PAS toto comme propriété, ou comme méthode, alors qu'un formulaire Access expose ses contrôles et la syntaxe OOP, ou de classe, Me.NomDeControle, est alors permise, en plus de la syntaxe de collection par défaut, Me!NomDeControle. -----------------------------------------------------------------
A+ Pierre (3stone) Access MVP Perso: http://www.3stone.be/ Conseils MPFA: http://www.mpfa.info/
Bonsoir Pierre,
Ca ne change rien à l'affaire, je préfère une erreur de compil à une erreur d'exécution :-)
donc, très mauvais :-)
Même si Michel Walsh pense le contraire :-)
En plus, si tu relis sa phrase, elle ne veut rien dire. Je cite:
Personnellement, j'ajouterai que pour ceux qui utilise le "prémaché" d'Access,
il est plus prudent d'utiliser le point "." pour se référer à un champ (de la source)
mais d'utiliser un point d'exclamation "!" pour se référer à une zone de texte (un 'controle')
J-Pierre
PS: En fait, je m'en fous un peu, chacun utilise la méthode qu'il préfère :-)
"3stone" <home@sweet_home.be> a écrit dans le message de news: %23FnHPYkkGHA.408@TK2MSFTNGP03.phx.gbl...
Salut,
"J-Pierre"
[...]
| En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de syntaxe ne sont détectées qu'à
l'exécution, alors qu'avec
| "Me.[MonChamp]", c'est détecté à la compilation.
"très mauvais" ?? ;-)
Ci dessous un vieux post que j'ai déterré (Mishel Walsh ;-)
Personnellement, j'ajouterai que pour ceux qui utilise le "prémaché" d'Access,
il est plus prudent d'utiliser le point "." pour se référer à un champ (de la source)
mais d'utiliser un point d'exclamation "!" pour se référer à une zone de texte (un 'controle')
Le fait que l'erreur de syntaxe ne soit détectée qu'à l'exécution, n'est qu'un (léger)
inconvénient en rapport des problèmes que peut apporter le fait que les zones
de texte possèdent "par défaut" le même nom que leur source !!
Ceci n'est que mon avis (mais qui compte beaucoup pour moi ;-))
--------------------------------------------------------------------------------------
--- juillet 2002 --- Michel Walsh
--------------------------------------------------------------------------------------
Le point refère à une propriété ou à une méthode. Me.NomDeContrôle refère au nom du contrôle en
voyant le formulaire comme une classe qui expose le contrôle comme propriété (ou sous classe).
Le ! est un barbarisme qui est à utiliser lorsque les deux conditions suivantes sont remplies:
- on réfère à un élément d'une collection
- la collection à laquelle on réfère est une collection "par défaut"
Un simple exemple éclaircit le point:
rst.Fields("toto")
versus
rst!toto
On ne peut évidemment pas utiliser le point:
rs.toto
car un recordset ADO ou DAO n'expose PAS toto comme propriété, ou comme méthode, alors qu'un
formulaire Access expose ses contrôles et la syntaxe OOP, ou de classe, Me.NomDeControle, est
alors permise, en plus de la syntaxe de collection par défaut, Me!NomDeControle.
-----------------------------------------------------------------
A+
Pierre (3stone) Access MVP
Perso: http://www.3stone.be/
Conseils MPFA: http://www.mpfa.info/
Ca ne change rien à l'affaire, je préfère une erreur de compil à une erreur d'exécution :-) donc, très mauvais :-)
Même si Michel Walsh pense le contraire :-)
En plus, si tu relis sa phrase, elle ne veut rien dire. Je cite:
Personnellement, j'ajouterai que pour ceux qui utilise le "prémaché" d'Access, il est plus prudent d'utiliser le point "." pour se référer à un champ (de la source) mais d'utiliser un point d'exclamation "!" pour se référer à une zone de texte (un 'controle')
J-Pierre
PS: En fait, je m'en fous un peu, chacun utilise la méthode qu'il préfère :-)
"3stone" a écrit dans le message de news: %
Salut,
"J-Pierre" [...] | En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de syntaxe ne sont détectées qu'à l'exécution, alors qu'avec | "Me.[MonChamp]", c'est détecté à la compilation.
"très mauvais" ?? ;-)
Ci dessous un vieux post que j'ai déterré (Mishel Walsh ;-)
Personnellement, j'ajouterai que pour ceux qui utilise le "prémaché" d'Access, il est plus prudent d'utiliser le point "." pour se référer à un champ (de la source) mais d'utiliser un point d'exclamation "!" pour se référer à une zone de texte (un 'controle')
Le fait que l'erreur de syntaxe ne soit détectée qu'à l'exécution, n'est qu'un (léger) inconvénient en rapport des problèmes que peut apporter le fait que les zones de texte possèdent "par défaut" le même nom que leur source !!
Ceci n'est que mon avis (mais qui compte beaucoup pour moi ;-))
-------------------------------------------------------------------------------------- --- juillet 2002 --- Michel Walsh -------------------------------------------------------------------------------------- Le point refère à une propriété ou à une méthode. Me.NomDeContrôle refère au nom du contrôle en voyant le formulaire comme une classe qui expose le contrôle comme propriété (ou sous classe).
Le ! est un barbarisme qui est à utiliser lorsque les deux conditions suivantes sont remplies: - on réfère à un élément d'une collection - la collection à laquelle on réfère est une collection "par défaut"
Un simple exemple éclaircit le point:
rst.Fields("toto")
versus
rst!toto
On ne peut évidemment pas utiliser le point:
rs.toto
car un recordset ADO ou DAO n'expose PAS toto comme propriété, ou comme méthode, alors qu'un formulaire Access expose ses contrôles et la syntaxe OOP, ou de classe, Me.NomDeControle, est alors permise, en plus de la syntaxe de collection par défaut, Me!NomDeControle. -----------------------------------------------------------------
A+ Pierre (3stone) Access MVP Perso: http://www.3stone.be/ Conseils MPFA: http://www.mpfa.info/
3stone
Salut,
"J-Pierre" | En plus, si tu relis sa phrase, elle ne veut rien dire. Je cite:
Ca, ce n'est pas 'sa' phrase, c'est de moi. L'explication de Michel se trouve sous sont nom !
J'ajouterai que si pour toi elle ne veut rien dire, c'est que tu confonds champ et zone de texte ;-)
| | PS: En fait, je m'en fous un peu, chacun utilise la méthode qu'il préfère :-) |
NB: Ceci dit: je me fous également... du fait que tu t'en foutte ;-))
"!" est mauvais. "." est détecté à la compilation.
Moi je veux juste que tout fonctionne sans problème, c'était le cas jusqu'à présent. Un sac de noeud !
"J-Pierre" a écrit dans le message de news:
Bonjour Fred,
Ta base est fatiguée ? début de corruption ? Tout importer dans une base vierge ? Si tu as des formulaires avec beaucoup de code VBA (je parle de 1500/2000 lignes) , parfois, Access bouffe une partie du code......
En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de syntaxe ne sont détectées qu'à l'exécution, alors qu'avec "Me.[MonChamp]", c'est détecté à la compilation.
J-Pierre
"Fred" a écrit dans le message de news: 4492a017$0$1019$
Du forum, bonjour,
Des années que je travaille sur cette base: Depuis ce matin, certains formulaires ou états de mon application n'acceptent plus la syntaxe "Me.[MonChamp]", et je suis obligé de remplacer le point par un point d'exclamation: "Me![MonChamp]". Le problème, c'est que mon application est énorme et que je ne peux pas m'amuser à changer les itérations par la méthode <Ctrl>+H
La grande question: Pourquoi ce problème depuis aujourd'hui ? Pourquoi seulement sur certains éléments de ma base ? Est-ce un problème de références VBA ?
Merci d'avance à ceux qui peuvent m'aider.
Fred
OK
Merci pour ta réponse
"!" est mauvais.
"." est détecté à la compilation.
Moi je veux juste que tout fonctionne sans problème, c'était le cas jusqu'à
présent.
Un sac de noeud !
"J-Pierre" <pas.de.pub.jpberchtold@hotmail.com> a écrit dans le message de
news: eMySvlfkGHA.2280@TK2MSFTNGP02.phx.gbl...
Bonjour Fred,
Ta base est fatiguée ? début de corruption ? Tout importer dans une base
vierge ? Si tu as des formulaires avec beaucoup de code VBA (je parle de
1500/2000 lignes) , parfois, Access bouffe une partie du code......
En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de
syntaxe ne sont détectées qu'à l'exécution, alors qu'avec "Me.[MonChamp]",
c'est détecté à la compilation.
J-Pierre
"Fred" <fred@memorys.fr> a écrit dans le message de news:
4492a017$0$1019$ba4acef3@news.orange.fr...
Du forum, bonjour,
Des années que je travaille sur cette base:
Depuis ce matin, certains formulaires ou états de mon application
n'acceptent plus la syntaxe "Me.[MonChamp]", et je suis obligé de
remplacer le point par un point d'exclamation: "Me![MonChamp]".
Le problème, c'est que mon application est énorme et que je ne peux pas
m'amuser à changer les itérations par la méthode <Ctrl>+H
La grande question:
Pourquoi ce problème depuis aujourd'hui ?
Pourquoi seulement sur certains éléments de ma base ?
Est-ce un problème de références VBA ?
"!" est mauvais. "." est détecté à la compilation.
Moi je veux juste que tout fonctionne sans problème, c'était le cas jusqu'à présent. Un sac de noeud !
"J-Pierre" a écrit dans le message de news:
Bonjour Fred,
Ta base est fatiguée ? début de corruption ? Tout importer dans une base vierge ? Si tu as des formulaires avec beaucoup de code VBA (je parle de 1500/2000 lignes) , parfois, Access bouffe une partie du code......
En plus, coder "Me![MonChamp]" est très mauvais, car les erreurs de syntaxe ne sont détectées qu'à l'exécution, alors qu'avec "Me.[MonChamp]", c'est détecté à la compilation.
J-Pierre
"Fred" a écrit dans le message de news: 4492a017$0$1019$
Du forum, bonjour,
Des années que je travaille sur cette base: Depuis ce matin, certains formulaires ou états de mon application n'acceptent plus la syntaxe "Me.[MonChamp]", et je suis obligé de remplacer le point par un point d'exclamation: "Me![MonChamp]". Le problème, c'est que mon application est énorme et que je ne peux pas m'amuser à changer les itérations par la méthode <Ctrl>+H
La grande question: Pourquoi ce problème depuis aujourd'hui ? Pourquoi seulement sur certains éléments de ma base ? Est-ce un problème de références VBA ?
