listbox

X

27/03/2006 à 23:00

Bonsoir,

Comme ça:

For i = 0 To List1.ListCount - 1
If List1.Selected(i) Then List2.AddItem List1.List(i)
Next

------
Site logiciels
http://irolog.free.fr
Mail
http://irolog.free.fr/ecrire/index.htm
Site perso
http://irolog.free.fr/joe/index.htm
Principe d'utilisation des news Groups
http://support.microsoft.com/directory/worldwide/fr/newsgroup/regles.htm
------------------------------------------------------------------------------------
"Irrypétagoyenborda" a écrit dans le message de news:
maYVf.308$

Bonjour,
Question déjà posé dans public.fr.excel, mais je pense que pour quelqe
chose
d'aussi 'basique', vb ou vba doit être identque :

J'ai un useform avec deux listbox et un bouton.
je veux, au clic sur le bouton, faire passer les éléments selectionnés de
listbox1 vers listbox2 : ça marche pour un élément (avec listindex), mais
je
ne trouve pas comment faire pour faire passer tous les éléments d'une
selection multiple d'un coup.
celà se fait-il de façon simple ou faut-il faire une boucle ?
si boucle, comment est repéré un élément selectionné dans listbox ?

merci d'avance pour votre aide.

Irrypétagoyenborda

27/03/2006 à 23:18

Merci.

C'est vraiment la syntaxe et les éléments de langage que je dois apprendre.
Je suis un 'vieux' qui bricolais autrefois en basic, et j'avoue être très
désorienté par cette structure. C'est bien ça qu'on appelle un langage
'objet' ?

X

27/03/2006 à 23:34

Oui, l'objet étant en fait la form, et les listes dans cette dernière...
Rien n'est nouveau dans l'absolu, jadis on se faisait ses propres objets
quand c'était répétitif, désormais les langages visuels permettent de
disposer et de paramétrer des objets pré-conçus, qui reçoive des propriétés,
des méthodes et des évènements...

Pour savoir ce qu'est capable de faire un objet, il suffit généralement de
taper son son suivi d'un point:
nom_objet.
Et une liste se déroule...

------
Site logiciels
http://irolog.free.fr
Mail
http://irolog.free.fr/ecrire/index.htm
Site perso
http://irolog.free.fr/joe/index.htm
Principe d'utilisation des news Groups
http://support.microsoft.com/directory/worldwide/fr/newsgroup/regles.htm
------------------------------------------------------------------------------------
"Irrypétagoyenborda" a écrit dans le message de news:
kEYVf.316$

Merci.

C'est vraiment la syntaxe et les éléments de langage que je dois
apprendre.
Je suis un 'vieux' qui bricolais autrefois en basic, et j'avoue être très
désorienté par cette structure. C'est bien ça qu'on appelle un langage
'objet' ?

Guy DETIENNE

04/04/2006 à 22:03

Salut ;O)

L'orienté objet est bien plus que cela. Tu passes par un raccourci qui
pourrait tromper le 'profane'.

Pour Irrypétagoyenborda, voir le lien ici concernant la Programmation
Orientée Objet (POO):
http://www.commentcamarche.net/poo/poointro.php3

Sachons aussi qu'un langage orienté objet doit impérativement suivre ces 3
notions de la POO :

Le polymorphisme : http://www.commentcamarche.net/poo/polymorp.php3
L'encapsulation : http://www.commentcamarche.net/poo/encapsul.php3
L'héritage : http://www.commentcamarche.net/poo/heritage.php3

Pour info, VB6 n'étant pas capable d'appliquer l'héritage d'implémentation
mais seulement d'interfaces (voir plus bas), il n'est donc pas orienté objet
à 100% donc n'entre pas dans la cours des 'grands' comme le C++, Delphi,
Java, Eiffel ...
Ceci dit, on s'en tire à merveille sans cela ;O)

Et toujours pour Irrypétagoyenborda, VB6 est basé sur une programmation
événementielle :
"La programmation des applications avec interface graphique est également
nommée programmation événementielle. Contrairement à un programme séquentiel
qui traite un ensemble de tâches puis s'arrête, le programme événementiel
attend les ordres de l'utilisateur, un clic de souris, la frappe d'une
touche, etc. pour exécuter ce qui est demandé et se replace en attente.

Dans un premier temps, lorsque l'utilisateur interagit avec l'application
par l'entremise d'un contrôle (un bouton sur lequel on clique, une fenêtre
que l'on ferme, etc.), ce dernier émet un signal (par exemple destroy
lorsque l'on ferme une fenêtre). Chaque contrôle est associé à un ou
plusieurs signaux et permet donc ainsi de programmer toutes les actions
possibles.

Ce signal va ensuite être intercepté par une boucle évènementielle qui va
vérifier qu'une action spécifique à ce signal et ce contrôle a bien été
définie. Si tel est le cas, la fonction associée sera exécutée. Ce type de
fonction s'appelle fonction callback en anglais qu'on peut traduire par
fonction ou procédure de rappel.

Il faut donc créer une fonction de rappel pour chacun des évènements
susceptible d'avoir lieu pendant l'exécution du programme et associer (ou
connecter) cette fonction à un signal."

Bonne chance.

Guy

PS: un peu de lecteur sur comment VB6 fonctionne en orienté objet:

Polymorphisme dans Visual Basic
La plupart des systèmes de programmation orientée objet gère le
polymorphisme par l'intermédiaire de l'héritage. Par exemple, les classes
Flea et Tyrannosaur pourraient toutes deux hériter des caractéristiques
d'une classe Animal. Dans les deux classes, la méthode Bite de la classe
Animal serait redéfinie, afin que soient conservées les spécificités des
classes Flea et Tyrannosaur.

Le polymorphisme permet d'appeler la méthode Bite d'un objet appartenant à
une classe quelconque dérivée d'Animal, sans savoir à quelle classe
appartient l'objet.

Polymorphisme par interface
Visual Basic n'a pas recours à l'héritage pour gérer le polymorphisme ; il
prend en charge le polymorphisme par l'intermédiaire de plusieurs interfaces
ActiveX. Dans le modèle COM (Component Object Model) qui constitue
l'infrastructure de la technologie ActiveX, plusieurs interfaces permettent
d'assurer l'évolution des systèmes de composants logiciels en conservant le
code existant.

Une interface est un ensemble de propriétés et de méthodes connexes. La
majeure partie de la technologie ActiveX concerne la mise en ½uvre
d'interfaces standard fournissant des services système ou des
fonctionnalités à d'autres programmes.

Dans Visual Basic, vous pouvez créer une interface Animal et l'implémenter
dans les classes Flea et Tyrannosaur. Vous pouvez ensuite appeler la méthode
Bite de tout type d'objet, sans connaître ce dernier.

Polymorphisme et performances
Le polymorphisme a une grande incidence sur les performances. Cet aspect est
illustré dans la fonction suivante :

Public Sub GetFood(ByVal Critter As Object, _
ByVal Food As Object)
Dim dblDistance As Double
' Code calculant la distance jusqu'à la nourriture
' (omis).
Critter.Move dblDistance ' Late bound
Critter.Bite Food ' Late bound
End Sub
Les méthodes Move et Bite sont à liaison tardive sur Critter. Une liaison
tardive se produit lorsque Visual Basic ne peut déterminer au moment de la
compilation le type d'objet que va contenir une variable. Dans cet exemple,
l'argument Critter (créature) est déclaré avec As Object. Au moment de
l'exécution, il peut donc contenir une référence à n'importe quel type
d'objet, Car ou Rock, par exemple.

Visual Basic, qui ne peut prévoir quel sera l'objet, compile du code
supplémentaire pour vérifier que l'objet prend en charge la méthode appelée.
Dans l'affirmative, ce code supplémentaire l'appelle ; dans le cas
contraire, le code supplémentaire déclenche une erreur. Tous les appels de
méthode ou de propriété impliquent ce traitement additionnel.

En revanche, les interfaces permettent les liaisons précoces. Lorsque Visual
Basic sait, au moment de la compilation, quelle interface est appelée, il
peut vérifier dans la bibliothèque de types si l'interface prend en charge
la méthode. Visual Basic peut alors intégrer à la compilation un passage
direct à la méthode en utilisant une table de fonction virtuelle (vtable).
Cette approche est bien plus rapide que la liaison tardive.

Imaginons maintenant que les méthodes Move et Bite appartiennent à une
interface Animal et que toutes les classes à nom d'animal implémentent cette
interface. L'argument Critter peut désormais être déclaré avec As Animal et
les méthodes Move et Bite feront l'objet d'une liaison précoce :

Public Sub GetFood(ByVal Critter As Animal, _
ByVal Food As Object)
Dim dblDistance As Double
' Code calculant la distance jusqu'à la nourriture (omis).
Critter.Move dblDistance ' Liaison précoce (vtable).
Critter.Bite Food ' Liaison précoce (vtable).
End Sub
Mise à disposition du polymorphisme par l'implémentation des interfaces
Une des caractéristiques les plus surprenantes du modèle d'objet composant
(COM, Component Object Model) est la possibilité offerte à un objet
d'implémenter des interfaces multiples. Outre l'activation du polymorphisme,
les interfaces multiples offrent un mécanisme de développement progressif ou
par étapes qui rend superflue la recompilation de tous les composants du
système en cas de modifications.

En définissant les caractéristiques en termes d'interfaces, composées de
petits groupes de fonctions étroitement liées, vous pouvez implémenter les
caractéristiques du composant au fur et à mesure des besoins en sachant que
vous pouvez les développer ultérieurement en ajoutant simplement des
interfaces supplémentaires.

Il est ainsi plus simple de préserver la compatibilité, étant donné que les
nouvelles versions d'un composant peuvent continuer à fournir des interfaces
existantes tout en ajoutant de nouvelles interfaces ou des interfaces
améliorées qui peuvent être exploitées par les versions successives des
applications client lorsque cela s'avère utile.

Héritage et polymorphisme
La plupart des outils de programmation orientée objet autorisent le
polymorphisme par l'intermédiaire de l'héritage, comme expliqué à la section
« Polymorphisme » du chapitre « Utilisation d'objets en programmation » du
Guide de l'utilisateur de Visual Basic. Comme il s'agit d'un mécanisme
puissant pour les tâches de développement à échelle réduite, il a souvent
engendré des problèmes sur les grands systèmes.

Ces difficultés sont partiellement dues aux modifications nécessaires
apportées au c½ur même du graphe d'héritage des classes. Pour bénéficier de
ces modifications, une recompilation s'impose. En cas d'échec, vous risquez
d'être confronté à des surprises désagréables au moment où vous n'avez plus
d'autre choix que de sortir une nouvelle version.

Plus sérieusement, si vous mettez trop l'accent sur le polymorphisme piloté
par héritage, vous serez normalement amené à déplacer une partie
considérable des ressources consacrées aux tâches de développement pour les
affecter à des tâches d'analyse importantes, ce qui ne résoudra en rien le
retard accumulé dans le développement, pas plus que cela ne réduira
l'attente des utilisateurs finals, anxieux de disposer de l'application pour
découvrir si elle répond bien à leur besoins.

En conséquence, les outils destinés au prototypage rapide et au
développement rapide d'applications (RAD, Rapid Application Development) ont
supplanté les outils de programmation orientée objet (OOP, Object-Oriented
Programming).

Visual Basic et COM
Visual Basic suit l'exemple de COM en considérant les interfaces multiples
comme un moyen d'accès au polymorphisme plus souple. Le logiciel peut
évoluer de manière différente selon l'interface au lieu de dépendre de tous
les versions précédentes, ce qui allonge le processus de création.

Initialement, les objets peuvent être petits et dotés de fonctionnalités
minimales. Au fil du temps, ils peuvent acquérir des caractéristiques
supplémentaires que leur utilisation effective aura fait apparaître. Le code
existant est protégé grâce à la poursuite de la prise en charge des
anciennes interfaces, parallèlement à l'implémentation des nouvelles.

Le mot clé Implements
Visual Basic fournit le mot clé Implements qui permet l'incorporation d'une
interface secondaire. Si, par exemple, votre projet fait référence à une
bibliothèque de types qui décrivait l'interface IFinance, vous pouvez placer
le code suivant dans un module de classe :

Implements IFinance
Comme les bibliothèques de types ne contiennent que des interfaces et aucune
implémentation, vous devriez ajouter du code pour chacune des propriétés et
méthodes de l'interface IFinance, de la manière décrite à la section «
Implémentation et utilisation d'interfaces standard ».

Une interface est un contrat
Lorsque vous créez une interface destinée à être utilisée avec le mécanisme
Implements, vous la figez pour toujours. Cet immobilisme de l'interface est
un principe important de la création des composants, car il protège les
systèmes existants qui ont été écrits pour une interface.

Lorsqu'il devient évident qu'une interface doit être améliorée, il faut en
créer une nouvelle qui pourrait être appelée Interface2, de manière à
indiquer sa relation avec l'interface existante.

Alors que la création trop fréquente de nouvelles interfaces peut encombrer
vos composants avec des interfaces inutiles, des interfaces bien conçues
sont généralement de petite taille et indépendantes les unes des autres, ce
qui réduit le risque d'altération des performances.

Construction des interfaces
Le processus de détermination des propriétés et des méthodes appartenant à
une interface est désigné sous le terme de construction.

En règle générale, vous devez regrouper dans une même interface quelques
fonctions étroitement liées. Si ces fonctions sont trop nombreuses,
l'interface est difficile à manier. Par ailleurs, en morcelant exagérément
une caractéristique, vous engendrez une surcharge supplémentaire. Le code
suivant, par exemple, appelle des méthodes de trois interfaces différentes
de la classe Velociraptor :

Public Sub CretaceousToDoList(ByVal vcr1 As _
Velociraptor, ByVal vcr2 As Velociraptor)
Dim dnr As IDinosaur
Dim prd As IPredator
vcr1.Mate vcr2
Set dnr = vcr1
dnr.LayEggs
Set prd = vcr1
prd.KillSomethingAndEatIt
End Sub
Pour utiliser les méthodes des interfaces IDinosaur et IPredator, vous devez
affecter l'objet à une variable du type d'interface correct.

Dans la mesure du possible, les interfaces conçues pour utiliser des
structures de données souples dureront plus longtemps que les interfaces
fondées sur des types de données fixes.

Comme indiqué plus haut, le risque d'erreur est nettement moins élevé si
vous créez des interfaces plutôt que de créer des graphes d'héritage de
grande taille. En limitant la taille initiale, vous parviendrez assez
rapidement à exécuter des éléments d'un ...

"X" a écrit dans le message de
news:

Oui, l'objet étant en fait la form, et les listes dans cette dernière...
Rien n'est nouveau dans l'absolu, jadis on se faisait ses propres objets
quand c'était répétitif, désormais les langages visuels permettent de
disposer et de paramétrer des objets pré-conçus, qui reçoive des

propriétés,

des méthodes et des évènements...

Pour savoir ce qu'est capable de faire un objet, il suffit généralement de
taper son son suivi d'un point:
nom_objet.
Et une liste se déroule...

------
Site logiciels
http://irolog.free.fr
Mail
http://irolog.free.fr/ecrire/index.htm
Site perso
http://irolog.free.fr/joe/index.htm
Principe d'utilisation des news Groups
http://support.microsoft.com/directory/worldwide/fr/newsgroup/regles.htm
--------------------------------------------------------------------------

----------

"Irrypétagoyenborda" a écrit dans le message de news:
kEYVf.316$
> Merci.
>
> C'est vraiment la syntaxe et les éléments de langage que je dois
> apprendre.
> Je suis un 'vieux' qui bricolais autrefois en basic, et j'avoue être

très

> désorienté par cette structure. C'est bien ça qu'on appelle un langage
> 'objet' ?
>
>
>

Salut ;O)

L'orienté objet est bien plus que cela. Tu passes par un raccourci qui
pourrait tromper le 'profane'.

Pour Irrypétagoyenborda, voir le lien ici concernant la Programmation
Orientée Objet (POO):
http://www.commentcamarche.net/poo/poointro.php3

Sachons aussi qu'un langage orienté objet doit impérativement suivre ces 3
notions de la POO :

Le polymorphisme : http://www.commentcamarche.net/poo/polymorp.php3
L'encapsulation : http://www.commentcamarche.net/poo/encapsul.php3
L'héritage : http://www.commentcamarche.net/poo/heritage.php3

Pour info, VB6 n'étant pas capable d'appliquer l'héritage d'implémentation
mais seulement d'interfaces (voir plus bas), il n'est donc pas orienté objet
à 100% donc n'entre pas dans la cours des 'grands' comme le C++, Delphi,
Java, Eiffel ...
Ceci dit, on s'en tire à merveille sans cela ;O)

Et toujours pour Irrypétagoyenborda, VB6 est basé sur une programmation
événementielle :
"La programmation des applications avec interface graphique est également
nommée programmation événementielle. Contrairement à un programme séquentiel
qui traite un ensemble de tâches puis s'arrête, le programme événementiel
attend les ordres de l'utilisateur, un clic de souris, la frappe d'une
touche, etc. pour exécuter ce qui est demandé et se replace en attente.

Dans un premier temps, lorsque l'utilisateur interagit avec l'application
par l'entremise d'un contrôle (un bouton sur lequel on clique, une fenêtre
que l'on ferme, etc.), ce dernier émet un signal (par exemple destroy
lorsque l'on ferme une fenêtre). Chaque contrôle est associé à un ou
plusieurs signaux et permet donc ainsi de programmer toutes les actions
possibles.

Ce signal va ensuite être intercepté par une boucle évènementielle qui va
vérifier qu'une action spécifique à ce signal et ce contrôle a bien été
définie. Si tel est le cas, la fonction associée sera exécutée. Ce type de
fonction s'appelle fonction callback en anglais qu'on peut traduire par
fonction ou procédure de rappel.

Il faut donc créer une fonction de rappel pour chacun des évènements
susceptible d'avoir lieu pendant l'exécution du programme et associer (ou
connecter) cette fonction à un signal."

Bonne chance.

Guy

PS: un peu de lecteur sur comment VB6 fonctionne en orienté objet:

Polymorphisme dans Visual Basic
La plupart des systèmes de programmation orientée objet gère le
polymorphisme par l'intermédiaire de l'héritage. Par exemple, les classes
Flea et Tyrannosaur pourraient toutes deux hériter des caractéristiques
d'une classe Animal. Dans les deux classes, la méthode Bite de la classe
Animal serait redéfinie, afin que soient conservées les spécificités des
classes Flea et Tyrannosaur.

Le polymorphisme permet d'appeler la méthode Bite d'un objet appartenant à
une classe quelconque dérivée d'Animal, sans savoir à quelle classe
appartient l'objet.

Polymorphisme par interface
Visual Basic n'a pas recours à l'héritage pour gérer le polymorphisme ; il
prend en charge le polymorphisme par l'intermédiaire de plusieurs interfaces
ActiveX. Dans le modèle COM (Component Object Model) qui constitue
l'infrastructure de la technologie ActiveX, plusieurs interfaces permettent
d'assurer l'évolution des systèmes de composants logiciels en conservant le
code existant.

Une interface est un ensemble de propriétés et de méthodes connexes. La
majeure partie de la technologie ActiveX concerne la mise en ½uvre
d'interfaces standard fournissant des services système ou des
fonctionnalités à d'autres programmes.

Dans Visual Basic, vous pouvez créer une interface Animal et l'implémenter
dans les classes Flea et Tyrannosaur. Vous pouvez ensuite appeler la méthode
Bite de tout type d'objet, sans connaître ce dernier.

Polymorphisme et performances
Le polymorphisme a une grande incidence sur les performances. Cet aspect est
illustré dans la fonction suivante :

Public Sub GetFood(ByVal Critter As Object, _
ByVal Food As Object)
Dim dblDistance As Double
' Code calculant la distance jusqu'à la nourriture
' (omis).
Critter.Move dblDistance ' Late bound
Critter.Bite Food ' Late bound
End Sub
Les méthodes Move et Bite sont à liaison tardive sur Critter. Une liaison
tardive se produit lorsque Visual Basic ne peut déterminer au moment de la
compilation le type d'objet que va contenir une variable. Dans cet exemple,
l'argument Critter (créature) est déclaré avec As Object. Au moment de
l'exécution, il peut donc contenir une référence à n'importe quel type
d'objet, Car ou Rock, par exemple.

Visual Basic, qui ne peut prévoir quel sera l'objet, compile du code
supplémentaire pour vérifier que l'objet prend en charge la méthode appelée.
Dans l'affirmative, ce code supplémentaire l'appelle ; dans le cas
contraire, le code supplémentaire déclenche une erreur. Tous les appels de
méthode ou de propriété impliquent ce traitement additionnel.

En revanche, les interfaces permettent les liaisons précoces. Lorsque Visual
Basic sait, au moment de la compilation, quelle interface est appelée, il
peut vérifier dans la bibliothèque de types si l'interface prend en charge
la méthode. Visual Basic peut alors intégrer à la compilation un passage
direct à la méthode en utilisant une table de fonction virtuelle (vtable).
Cette approche est bien plus rapide que la liaison tardive.

Imaginons maintenant que les méthodes Move et Bite appartiennent à une
interface Animal et que toutes les classes à nom d'animal implémentent cette
interface. L'argument Critter peut désormais être déclaré avec As Animal et
les méthodes Move et Bite feront l'objet d'une liaison précoce :

Public Sub GetFood(ByVal Critter As Animal, _
ByVal Food As Object)
Dim dblDistance As Double
' Code calculant la distance jusqu'à la nourriture (omis).
Critter.Move dblDistance ' Liaison précoce (vtable).
Critter.Bite Food ' Liaison précoce (vtable).
End Sub
Mise à disposition du polymorphisme par l'implémentation des interfaces
Une des caractéristiques les plus surprenantes du modèle d'objet composant
(COM, Component Object Model) est la possibilité offerte à un objet
d'implémenter des interfaces multiples. Outre l'activation du polymorphisme,
les interfaces multiples offrent un mécanisme de développement progressif ou
par étapes qui rend superflue la recompilation de tous les composants du
système en cas de modifications.

En définissant les caractéristiques en termes d'interfaces, composées de
petits groupes de fonctions étroitement liées, vous pouvez implémenter les
caractéristiques du composant au fur et à mesure des besoins en sachant que
vous pouvez les développer ultérieurement en ajoutant simplement des
interfaces supplémentaires.

Il est ainsi plus simple de préserver la compatibilité, étant donné que les
nouvelles versions d'un composant peuvent continuer à fournir des interfaces
existantes tout en ajoutant de nouvelles interfaces ou des interfaces
améliorées qui peuvent être exploitées par les versions successives des
applications client lorsque cela s'avère utile.

Héritage et polymorphisme
La plupart des outils de programmation orientée objet autorisent le
polymorphisme par l'intermédiaire de l'héritage, comme expliqué à la section
« Polymorphisme » du chapitre « Utilisation d'objets en programmation » du
Guide de l'utilisateur de Visual Basic. Comme il s'agit d'un mécanisme
puissant pour les tâches de développement à échelle réduite, il a souvent
engendré des problèmes sur les grands systèmes.

Ces difficultés sont partiellement dues aux modifications nécessaires
apportées au c½ur même du graphe d'héritage des classes. Pour bénéficier de
ces modifications, une recompilation s'impose. En cas d'échec, vous risquez
d'être confronté à des surprises désagréables au moment où vous n'avez plus
d'autre choix que de sortir une nouvelle version.

Plus sérieusement, si vous mettez trop l'accent sur le polymorphisme piloté
par héritage, vous serez normalement amené à déplacer une partie
considérable des ressources consacrées aux tâches de développement pour les
affecter à des tâches d'analyse importantes, ce qui ne résoudra en rien le
retard accumulé dans le développement, pas plus que cela ne réduira
l'attente des utilisateurs finals, anxieux de disposer de l'application pour
découvrir si elle répond bien à leur besoins.

En conséquence, les outils destinés au prototypage rapide et au
développement rapide d'applications (RAD, Rapid Application Development) ont
supplanté les outils de programmation orientée objet (OOP, Object-Oriented
Programming).

Visual Basic et COM
Visual Basic suit l'exemple de COM en considérant les interfaces multiples
comme un moyen d'accès au polymorphisme plus souple. Le logiciel peut
évoluer de manière différente selon l'interface au lieu de dépendre de tous
les versions précédentes, ce qui allonge le processus de création.

Initialement, les objets peuvent être petits et dotés de fonctionnalités
minimales. Au fil du temps, ils peuvent acquérir des caractéristiques
supplémentaires que leur utilisation effective aura fait apparaître. Le code
existant est protégé grâce à la poursuite de la prise en charge des
anciennes interfaces, parallèlement à l'implémentation des nouvelles.

Le mot clé Implements
Visual Basic fournit le mot clé Implements qui permet l'incorporation d'une
interface secondaire. Si, par exemple, votre projet fait référence à une
bibliothèque de types qui décrivait l'interface IFinance, vous pouvez placer
le code suivant dans un module de classe :

Implements IFinance
Comme les bibliothèques de types ne contiennent que des interfaces et aucune
implémentation, vous devriez ajouter du code pour chacune des propriétés et
méthodes de l'interface IFinance, de la manière décrite à la section «
Implémentation et utilisation d'interfaces standard ».

Une interface est un contrat
Lorsque vous créez une interface destinée à être utilisée avec le mécanisme
Implements, vous la figez pour toujours. Cet immobilisme de l'interface est
un principe important de la création des composants, car il protège les
systèmes existants qui ont été écrits pour une interface.

Lorsqu'il devient évident qu'une interface doit être améliorée, il faut en
créer une nouvelle qui pourrait être appelée Interface2, de manière à
indiquer sa relation avec l'interface existante.

Alors que la création trop fréquente de nouvelles interfaces peut encombrer
vos composants avec des interfaces inutiles, des interfaces bien conçues
sont généralement de petite taille et indépendantes les unes des autres, ce
qui réduit le risque d'altération des performances.

Construction des interfaces
Le processus de détermination des propriétés et des méthodes appartenant à
une interface est désigné sous le terme de construction.

En règle générale, vous devez regrouper dans une même interface quelques
fonctions étroitement liées. Si ces fonctions sont trop nombreuses,
l'interface est difficile à manier. Par ailleurs, en morcelant exagérément
une caractéristique, vous engendrez une surcharge supplémentaire. Le code
suivant, par exemple, appelle des méthodes de trois interfaces différentes
de la classe Velociraptor :

Public Sub CretaceousToDoList(ByVal vcr1 As _
Velociraptor, ByVal vcr2 As Velociraptor)
Dim dnr As IDinosaur
Dim prd As IPredator
vcr1.Mate vcr2
Set dnr = vcr1
dnr.LayEggs
Set prd = vcr1
prd.KillSomethingAndEatIt
End Sub
Pour utiliser les méthodes des interfaces IDinosaur et IPredator, vous devez
affecter l'objet à une variable du type d'interface correct.

Dans la mesure du possible, les interfaces conçues pour utiliser des
structures de données souples dureront plus longtemps que les interfaces
fondées sur des types de données fixes.

Comme indiqué plus haut, le risque d'erreur est nettement moins élevé si
vous créez des interfaces plutôt que de créer des graphes d'héritage de
grande taille. En limitant la taille initiale, vous parviendrez assez
rapidement à exécuter des éléments d'un ...

"X" <X@Y.Z> a écrit dans le message de
news:upg2uYeUGHA.4956@TK2MSFTNGP09.phx.gbl...

Oui, l'objet étant en fait la form, et les listes dans cette dernière...
Rien n'est nouveau dans l'absolu, jadis on se faisait ses propres objets
quand c'était répétitif, désormais les langages visuels permettent de
disposer et de paramétrer des objets pré-conçus, qui reçoive des

propriétés,

des méthodes et des évènements...

Pour savoir ce qu'est capable de faire un objet, il suffit généralement de
taper son son suivi d'un point:
nom_objet.
Et une liste se déroule...

------
Site logiciels
http://irolog.free.fr
Mail
http://irolog.free.fr/ecrire/index.htm
Site perso
http://irolog.free.fr/joe/index.htm
Principe d'utilisation des news Groups
http://support.microsoft.com/directory/worldwide/fr/newsgroup/regles.htm
--------------------------------------------------------------------------

----------

"Irrypétagoyenborda" <le_mops@tele21.fr> a écrit dans le message de news:
kEYVf.316$Ft1.58@nntpserver.swip.net...
> Merci.
>
> C'est vraiment la syntaxe et les éléments de langage que je dois
> apprendre.
> Je suis un 'vieux' qui bricolais autrefois en basic, et j'avoue être

très

> désorienté par cette structure. C'est bien ça qu'on appelle un langage
> 'objet' ?
>
>
>

Vous avez filtré cet utilisateur ! Consultez son message

Salut ;O)

L'orienté objet est bien plus que cela. Tu passes par un raccourci qui
pourrait tromper le 'profane'.

Pour Irrypétagoyenborda, voir le lien ici concernant la Programmation
Orientée Objet (POO):
http://www.commentcamarche.net/poo/poointro.php3

Sachons aussi qu'un langage orienté objet doit impérativement suivre ces 3
notions de la POO :

Le polymorphisme : http://www.commentcamarche.net/poo/polymorp.php3
L'encapsulation : http://www.commentcamarche.net/poo/encapsul.php3
L'héritage : http://www.commentcamarche.net/poo/heritage.php3

Pour info, VB6 n'étant pas capable d'appliquer l'héritage d'implémentation
mais seulement d'interfaces (voir plus bas), il n'est donc pas orienté objet
à 100% donc n'entre pas dans la cours des 'grands' comme le C++, Delphi,
Java, Eiffel ...
Ceci dit, on s'en tire à merveille sans cela ;O)

Et toujours pour Irrypétagoyenborda, VB6 est basé sur une programmation
événementielle :
"La programmation des applications avec interface graphique est également
nommée programmation événementielle. Contrairement à un programme séquentiel
qui traite un ensemble de tâches puis s'arrête, le programme événementiel
attend les ordres de l'utilisateur, un clic de souris, la frappe d'une
touche, etc. pour exécuter ce qui est demandé et se replace en attente.

Dans un premier temps, lorsque l'utilisateur interagit avec l'application
par l'entremise d'un contrôle (un bouton sur lequel on clique, une fenêtre
que l'on ferme, etc.), ce dernier émet un signal (par exemple destroy
lorsque l'on ferme une fenêtre). Chaque contrôle est associé à un ou
plusieurs signaux et permet donc ainsi de programmer toutes les actions
possibles.

Ce signal va ensuite être intercepté par une boucle évènementielle qui va
vérifier qu'une action spécifique à ce signal et ce contrôle a bien été
définie. Si tel est le cas, la fonction associée sera exécutée. Ce type de
fonction s'appelle fonction callback en anglais qu'on peut traduire par
fonction ou procédure de rappel.

Il faut donc créer une fonction de rappel pour chacun des évènements
susceptible d'avoir lieu pendant l'exécution du programme et associer (ou
connecter) cette fonction à un signal."

Bonne chance.

Guy

PS: un peu de lecteur sur comment VB6 fonctionne en orienté objet:

Polymorphisme dans Visual Basic
La plupart des systèmes de programmation orientée objet gère le
polymorphisme par l'intermédiaire de l'héritage. Par exemple, les classes
Flea et Tyrannosaur pourraient toutes deux hériter des caractéristiques
d'une classe Animal. Dans les deux classes, la méthode Bite de la classe
Animal serait redéfinie, afin que soient conservées les spécificités des
classes Flea et Tyrannosaur.

Le polymorphisme permet d'appeler la méthode Bite d'un objet appartenant à
une classe quelconque dérivée d'Animal, sans savoir à quelle classe
appartient l'objet.

Polymorphisme par interface
Visual Basic n'a pas recours à l'héritage pour gérer le polymorphisme ; il
prend en charge le polymorphisme par l'intermédiaire de plusieurs interfaces
ActiveX. Dans le modèle COM (Component Object Model) qui constitue
l'infrastructure de la technologie ActiveX, plusieurs interfaces permettent
d'assurer l'évolution des systèmes de composants logiciels en conservant le
code existant.

Une interface est un ensemble de propriétés et de méthodes connexes. La
majeure partie de la technologie ActiveX concerne la mise en ½uvre
d'interfaces standard fournissant des services système ou des
fonctionnalités à d'autres programmes.

Dans Visual Basic, vous pouvez créer une interface Animal et l'implémenter
dans les classes Flea et Tyrannosaur. Vous pouvez ensuite appeler la méthode
Bite de tout type d'objet, sans connaître ce dernier.

Polymorphisme et performances
Le polymorphisme a une grande incidence sur les performances. Cet aspect est
illustré dans la fonction suivante :

Public Sub GetFood(ByVal Critter As Object, _
ByVal Food As Object)
Dim dblDistance As Double
' Code calculant la distance jusqu'à la nourriture
' (omis).
Critter.Move dblDistance ' Late bound
Critter.Bite Food ' Late bound
End Sub
Les méthodes Move et Bite sont à liaison tardive sur Critter. Une liaison
tardive se produit lorsque Visual Basic ne peut déterminer au moment de la
compilation le type d'objet que va contenir une variable. Dans cet exemple,
l'argument Critter (créature) est déclaré avec As Object. Au moment de
l'exécution, il peut donc contenir une référence à n'importe quel type
d'objet, Car ou Rock, par exemple.

Visual Basic, qui ne peut prévoir quel sera l'objet, compile du code
supplémentaire pour vérifier que l'objet prend en charge la méthode appelée.
Dans l'affirmative, ce code supplémentaire l'appelle ; dans le cas
contraire, le code supplémentaire déclenche une erreur. Tous les appels de
méthode ou de propriété impliquent ce traitement additionnel.

En revanche, les interfaces permettent les liaisons précoces. Lorsque Visual
Basic sait, au moment de la compilation, quelle interface est appelée, il
peut vérifier dans la bibliothèque de types si l'interface prend en charge
la méthode. Visual Basic peut alors intégrer à la compilation un passage
direct à la méthode en utilisant une table de fonction virtuelle (vtable).
Cette approche est bien plus rapide que la liaison tardive.

Imaginons maintenant que les méthodes Move et Bite appartiennent à une
interface Animal et que toutes les classes à nom d'animal implémentent cette
interface. L'argument Critter peut désormais être déclaré avec As Animal et
les méthodes Move et Bite feront l'objet d'une liaison précoce :

Public Sub GetFood(ByVal Critter As Animal, _
ByVal Food As Object)
Dim dblDistance As Double
' Code calculant la distance jusqu'à la nourriture (omis).
Critter.Move dblDistance ' Liaison précoce (vtable).
Critter.Bite Food ' Liaison précoce (vtable).
End Sub
Mise à disposition du polymorphisme par l'implémentation des interfaces
Une des caractéristiques les plus surprenantes du modèle d'objet composant
(COM, Component Object Model) est la possibilité offerte à un objet
d'implémenter des interfaces multiples. Outre l'activation du polymorphisme,
les interfaces multiples offrent un mécanisme de développement progressif ou
par étapes qui rend superflue la recompilation de tous les composants du
système en cas de modifications.

En définissant les caractéristiques en termes d'interfaces, composées de
petits groupes de fonctions étroitement liées, vous pouvez implémenter les
caractéristiques du composant au fur et à mesure des besoins en sachant que
vous pouvez les développer ultérieurement en ajoutant simplement des
interfaces supplémentaires.

Il est ainsi plus simple de préserver la compatibilité, étant donné que les
nouvelles versions d'un composant peuvent continuer à fournir des interfaces
existantes tout en ajoutant de nouvelles interfaces ou des interfaces
améliorées qui peuvent être exploitées par les versions successives des
applications client lorsque cela s'avère utile.

Héritage et polymorphisme
La plupart des outils de programmation orientée objet autorisent le
polymorphisme par l'intermédiaire de l'héritage, comme expliqué à la section
« Polymorphisme » du chapitre « Utilisation d'objets en programmation » du
Guide de l'utilisateur de Visual Basic. Comme il s'agit d'un mécanisme
puissant pour les tâches de développement à échelle réduite, il a souvent
engendré des problèmes sur les grands systèmes.

Ces difficultés sont partiellement dues aux modifications nécessaires
apportées au c½ur même du graphe d'héritage des classes. Pour bénéficier de
ces modifications, une recompilation s'impose. En cas d'échec, vous risquez
d'être confronté à des surprises désagréables au moment où vous n'avez plus
d'autre choix que de sortir une nouvelle version.

Plus sérieusement, si vous mettez trop l'accent sur le polymorphisme piloté
par héritage, vous serez normalement amené à déplacer une partie
considérable des ressources consacrées aux tâches de développement pour les
affecter à des tâches d'analyse importantes, ce qui ne résoudra en rien le
retard accumulé dans le développement, pas plus que cela ne réduira
l'attente des utilisateurs finals, anxieux de disposer de l'application pour
découvrir si elle répond bien à leur besoins.

En conséquence, les outils destinés au prototypage rapide et au
développement rapide d'applications (RAD, Rapid Application Development) ont
supplanté les outils de programmation orientée objet (OOP, Object-Oriented
Programming).

Visual Basic et COM
Visual Basic suit l'exemple de COM en considérant les interfaces multiples
comme un moyen d'accès au polymorphisme plus souple. Le logiciel peut
évoluer de manière différente selon l'interface au lieu de dépendre de tous
les versions précédentes, ce qui allonge le processus de création.

Initialement, les objets peuvent être petits et dotés de fonctionnalités
minimales. Au fil du temps, ils peuvent acquérir des caractéristiques
supplémentaires que leur utilisation effective aura fait apparaître. Le code
existant est protégé grâce à la poursuite de la prise en charge des
anciennes interfaces, parallèlement à l'implémentation des nouvelles.

Le mot clé Implements
Visual Basic fournit le mot clé Implements qui permet l'incorporation d'une
interface secondaire. Si, par exemple, votre projet fait référence à une
bibliothèque de types qui décrivait l'interface IFinance, vous pouvez placer
le code suivant dans un module de classe :

Implements IFinance
Comme les bibliothèques de types ne contiennent que des interfaces et aucune
implémentation, vous devriez ajouter du code pour chacune des propriétés et
méthodes de l'interface IFinance, de la manière décrite à la section «
Implémentation et utilisation d'interfaces standard ».

Une interface est un contrat
Lorsque vous créez une interface destinée à être utilisée avec le mécanisme
Implements, vous la figez pour toujours. Cet immobilisme de l'interface est
un principe important de la création des composants, car il protège les
systèmes existants qui ont été écrits pour une interface.

Lorsqu'il devient évident qu'une interface doit être améliorée, il faut en
créer une nouvelle qui pourrait être appelée Interface2, de manière à
indiquer sa relation avec l'interface existante.

Alors que la création trop fréquente de nouvelles interfaces peut encombrer
vos composants avec des interfaces inutiles, des interfaces bien conçues
sont généralement de petite taille et indépendantes les unes des autres, ce
qui réduit le risque d'altération des performances.

Construction des interfaces
Le processus de détermination des propriétés et des méthodes appartenant à
une interface est désigné sous le terme de construction.

En règle générale, vous devez regrouper dans une même interface quelques
fonctions étroitement liées. Si ces fonctions sont trop nombreuses,
l'interface est difficile à manier. Par ailleurs, en morcelant exagérément
une caractéristique, vous engendrez une surcharge supplémentaire. Le code
suivant, par exemple, appelle des méthodes de trois interfaces différentes
de la classe Velociraptor :

Public Sub CretaceousToDoList(ByVal vcr1 As _
Velociraptor, ByVal vcr2 As Velociraptor)
Dim dnr As IDinosaur
Dim prd As IPredator
vcr1.Mate vcr2
Set dnr = vcr1
dnr.LayEggs
Set prd = vcr1
prd.KillSomethingAndEatIt
End Sub
Pour utiliser les méthodes des interfaces IDinosaur et IPredator, vous devez
affecter l'objet à une variable du type d'interface correct.

Dans la mesure du possible, les interfaces conçues pour utiliser des
structures de données souples dureront plus longtemps que les interfaces
fondées sur des types de données fixes.

Comme indiqué plus haut, le risque d'erreur est nettement moins élevé si
vous créez des interfaces plutôt que de créer des graphes d'héritage de
grande taille. En limitant la taille initiale, vous parviendrez assez
rapidement à exécuter des éléments d'un ...

"X" a écrit dans le message de
news:

Oui, l'objet étant en fait la form, et les listes dans cette dernière...
Rien n'est nouveau dans l'absolu, jadis on se faisait ses propres objets
quand c'était répétitif, désormais les langages visuels permettent de
disposer et de paramétrer des objets pré-conçus, qui reçoive des

propriétés,

des méthodes et des évènements...

Pour savoir ce qu'est capable de faire un objet, il suffit généralement de
taper son son suivi d'un point:
nom_objet.
Et une liste se déroule...

------
Site logiciels
http://irolog.free.fr
Mail
http://irolog.free.fr/ecrire/index.htm
Site perso
http://irolog.free.fr/joe/index.htm
Principe d'utilisation des news Groups
http://support.microsoft.com/directory/worldwide/fr/newsgroup/regles.htm
--------------------------------------------------------------------------

----------

"Irrypétagoyenborda" a écrit dans le message de news:
kEYVf.316$
> Merci.
>
> C'est vraiment la syntaxe et les éléments de langage que je dois
> apprendre.
> Je suis un 'vieux' qui bricolais autrefois en basic, et j'avoue être

très

> désorienté par cette structure. C'est bien ça qu'on appelle un langage
> 'objet' ?
>
>
>

bayosky

04/04/2006 à 23:11

Dans le message %,
Guy DETIENNE a écrit :

PS: un peu de lecteur sur comment VB6 fonctionne en orienté objet:

excellent !

HB

listbox

5 réponses

Veuillez sélectionner un problème