Discussion :

[BasicZX81]

Bonsoir, Désolé si ma question peux paraître basique mais les questions de base peuvent aussi être les plus importantes pour produire un bon code et je pense aussi que ça va intéresser beaucoup de monde. J'ai fait un exemple simple avec un code minimaliste pour bien comprendre qu'elle est le meilleur moyen pour passer 1 paramètre (que j'ai nommé Param) d'une Form1 vers une Form2.

J'ai aussi d'autres impératifs qu'il serait trop long à expliquer mais que j’évoquerais peut-être en fonction de vos suggestions.
Pour l'instant il s'agit de faire simple sachant que dans mon programme mon Paramètre ne sera pas une simple String mais des objets ou des variables que je n'ai pas encore définis précisément. Dans l'idée il faut pouvoir modifier le paramètre depuis Form1 et que l'on puisse relire celui-ci dans Form2. Bien sûre on pourrait utiliser la variable public Param dans les 2 Form mais est-ce la bonne façon de faire ?.

J'ai fait un code simple en utilisant Byref pour passer le paramètre mais apparemment ça ne suffit pas. Pourtant il me semblait que en utilisant byref on pouvait déclarer plusieurs variables pointant vers la même donnée en mémoire.

Le code de Form1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Public Class Form1
    Public Parametre As String
    Public MaForm2 As Form2
    Private Sub Form1_Load(sender As Object, e As System.EventArgs) Handles Me.Load
        Parametre = TextBoxParamètre.Text
        MaForm2 = New Form2(Parametre)
    End Sub
    Private Sub TextBoxParamétre_TextChanged(sender As System.Object, e As System.EventArgs) Handles TextBoxParamètre.TextChanged
        Parametre = TextBoxParamètre.Text
    End Sub
    Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles ButtonShoxForm2.Click
        MaForm2.Show()
    End Sub
End Class

Le code de Form2 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Public Class Form2
    Private _Paramètre As String
    Public Sub New()
 
        ' Cet appel est requis par le concepteur.
        InitializeComponent()
 
        ' Ajoutez une initialisation quelconque après l'appel InitializeComponent().
    End Sub
    Public Sub New(ByRef Param As String)
        Call Me.New()
        ' Ajoutez une initialisation quelconque après l'appel InitializeComponent().
        _Paramètre = Param
    End Sub
 
    Private Sub Form2_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
        Call Refresh()
    End Sub
 
    Private Sub ButtonRefresh_Click(sender As System.Object, e As System.EventArgs) Handles ButtonRefresh.Click
        TextBoxParamètre.Text = _Paramètre
    End Sub
End Class

Merci beaucoup pour vos conseils et suggestions.

[chaparo]

Salut,
Tu peux utiliser le pattern Singleton

[BasicZX81]

Merci chaparo, je ne connaissais pas les Singleton.
A priori je n'ai pas vraiment trouver de solution qui puisse s'adapter à toute les situations.
Finalement je vais faire suivant ce modèle :
(A noter que je fait l’économie du variable Public pour Param et je m'assure que le formulaire Form2 ne puisse pas se fermer).

Le Code de Form1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
Public Class Form1
    Public MaForm2 As New Form2
    Private Sub Form1_Load(sender As Object, e As System.EventArgs) Handles Me.Load
    End Sub
    Private Sub TextBoxParamétre_TextChanged(sender As System.Object, e As System.EventArgs) Handles TextBoxParamètre.TextChanged
        MaForm2.Paramètre = TextBoxParamètre.Text
    End Sub
    Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles ButtonShoxForm2.Click
        MaForm2.Show()
    End Sub
End Class

Le Code de Form 2 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Public Class Form2
    Private _Paramètre As String
    Public Sub New()
 
        ' Cet appel est requis par le concepteur.
        InitializeComponent()
 
        ' Ajoutez une initialisation quelconque après l'appel InitializeComponent().
    End Sub
 
    Public Property Paramètre() As String
        Get
            Return _Paramètre
        End Get
        Set(ByVal value As String)
            _Paramètre = value
            Call LoadData()
        End Set
    End Property
 
    Private Sub Form2_FormClosing(sender As Object, e As System.Windows.Forms.FormClosingEventArgs) Handles Me.FormClosing
        Me.Hide()
        e.Cancel = True
    End Sub
 
    Private Sub Form2_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
        Call LoadData()
    End Sub
    Private Sub LoadData()
        TextBoxParamètre.Text = _Paramètre
    End Sub
End Class

[Razorflak]

Autrement se que tu peux faire pour ne pas passer par des variables global, tu ajoute un constructeur à ta Form2 qui prend en paramètre une instance de ta Form1. De la tu pourras avoir accès et modifié tout se que tu veux sur ta Form2 depuis ta Form1.

[callo]

Tu peux passer les paramètres (texte, tableau, objet,...) voulus dans le constructeur de form2. Tu pourras ainsi les récupérer et effectuer les opérations désirées.
EDIT: grillé par Razorflak

[_Ez3kiel]

Il y a plusieurs moyens de faire ce que tu souhaites.

On peut :

• Passer les paramètres dans une surcharge du constructeur du form (pour plusieurs paramètres c'est Public Sub New(ByRef toto As Form1, ByRef SuperString As String, ByRef JeSaisPasQuoi As Object, ByRef [...]))
• Faire un module qui contiendra tes variables de travail accessibles depuis les 2 forms
• Rajouter des properties à tes formulaires
• Passer par des variables hautes Shared (ou pire, Public)(Je le dis parce que c'est une solution, mais c'est plutôt déprécié et pas franchement propre ...)

Après certaines solutions sont plus adaptées que d'autres relativement à l'application, sa finalité, le but des paramètres, etc.

En ce qui me concerne (et ce que je dis n'est pas parole d'évangile), j'évite les Modules et les variables hautes autant que peut se faire. (Même si parfois je m'autorise dans des petites appli éphémères.

Je me sers principalement des properties. (Que tu peux aussi remplir avec les paramètres que tu auras passé au constructeur) Il y a beaucoup d'ouvertures avec.

Exemple si ton form travaille principalement avec un objet Personne tu n'auras plus qu'à faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
    Private _laPersonne As Personne
    Public Property laPersonne As Personne
        Get
            Return _laPersonne
        End Get
        Set(value As Personne)
            _laPersonne = value
        End Set
    End Property

Et dans ton code tu pourras faire TextBox1.Text = laPersonne.NomPrenomOu même simplement avoir un property dans ton form2 qui travaille avec l'objet personnne de ton Form1

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    Public Property laPersonne As Personne
        Get
            If Form2 IsNot Nothing Then
                Return Form2.laPersonne
            Else
                Return Nothing
            End If
        End Get
        Set(value As Personne)
            If Form2 IsNot Nothing Then
                Form2.laPersonne = value
            Else
                Form2.laPersonne = Nothing
            End If
        End Set
    End Property

Bref, tout est possible et chaque problème a plusieurs solutions dont certaines plus adaptées que d'autres.

[BasicZX81]

Tu peux passer les paramètres (texte, tableau, objet,...) voulus dans le constructeur de form2. Tu pourras ainsi les récupérer et effectuer les opérations désirées.

Oui mais le passage de paramètres s'effectue au moment ou on instancie le formulaire Form2. Ensuite, après que Form2 soit instancié, si l'on modifie la valeur du paramétre dans Form1 cette valeur n'est pas répercuté dans Form2. Donc le seul fait de passer le paramétre dans le New() ne suffit pas a créer un lien entre les 2 Form malgré le fait que l'on passe le paramètre à l'aide de "Byref".

De plus je viens de faire une découverte importante qui remets en cause ce qui est noté dans un ouvrage pourtant très sérieux : (Manuel de référence Visual Basic de Francesco Balena).

Contrairement a ce qui est écrit en page 80 le type string n'est pas un type référence :
En effet, si on fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
        Dim s1 As String = "Valeur1"
        Dim s2 As String = s1
        s1 = "Valeur2"
        Debug.WriteLine(s2) 'Retourne Valeur1"
        Debug.WriteLine(s2 Is s1) ' Retourne False

On s'appercois que s1 est s2 ne pointent pas vers la même donnée malgré la déclaration s2=s1.

C'est peut-être pour cela que mon code du 1er Post ne fonctionne pas. Quelqu'un peux confirmer ? Y a t'il eu des changements dans le framework ou c'est moi ?

[Razorflak]

String est un type primitif, c'est pour cela que sa te retourne false, si tu fais la même chose pour un objet (un des controle de ta Form par exemple), ta 2e variable pointera bien vers ton premier objet.

[_Ez3kiel]

Vois ton code de façon linéaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 Dim s1 As String = "Valeur1" 'La machine met "Valeur1" à s1
        Dim s2 As String = s1 'La machine dit que s2 a la valeur de s1 à cet instant t
        s1 = "Valeur2" 'La machine dit que s1 a une nouvelle valeur à cet instant t+1
        Debug.WriteLine(s2) 'Retourne Valeur1"
        Debug.WriteLine(s2 Is s1) ' Retourne False

Pour retourner True il faudrait réactualiser la valeur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 Dim s1 As String = "Valeur1" 
        Dim s2 As String = s1 
        s1 = "Valeur2" 
        s2 = s1 '***
        Debug.WriteLine(s2) 'Retourne Valeur1"
        Debug.WriteLine(s2 Is s1) ' Retourne true

Et idem pour les formulaires. ('fin à peu près là c'est de l'ihm)

Ensuite, après que Form2 soit instancié, si l'on modifie la valeur du paramétre dans Form1 cette valeur n'est pas répercuté dans Form2

Si dans l'instance de Form1 que tu as passé en paramètre à Form2 tu fais Form1.BackColor = SuperDark, ton formulaire n'aura pas changé de couleur de lui même, mais avec un .Refresh() il se redessinera en SuperDark.

Et c'est ce qu'on a fait dans ma version de ton exemple avec s2 = s1 '***

[BasicZX81]

Je pensais qu'il n'existait que 2 types (type valeur et type référence) :
Type Référence : Les objets et les (string ?).
Type Valeur : Les Structures, les Integer, Single, boolean...etc.

Les types références :
- On peux déclarer 2 variables type références qui peuvent pointer sur la même donnée. Les variables type référence peuvent prendre la valeur Nothing.

Les types valeurs :
- 2 variables de types valeurs ne peuvent pas pointer sur la même donnée. Les variables de type valeur ne peuvent pas prendre la valeur Nothing.

Le type Primitif :
- Les string à priori (Post de Razorflak).

Quelqu'un peux m'aider à éclaircir tous ça ou me corriger, je commence à être un peu perdu.

[Razorflak]

Je mériterais d'être lapidé pour se qu j'ai dis dans mon précédent post, désolé. Les type primitif sont les type de variable que tu va trouvé dans System.*. Rien a voir avec les type référence ou valeur.

[BasicZX81]

J'ai trouvé une explication concernant les string :

Celles-ci sont bien un type référence dans le sens ou la variable ne contient pas directement la donné mais pointe vers un emplacement en mémoire. L'analogie au type référence s’arrête là puisque le type String a la particularité de se comporter comme un type valeur. C'est à dire que si on déclare s1=s2 on ne fait qu'assigner la valeur de s2 a s1. Les 2 variables étant complètement indépendante.
Ceci explique ma confusion. N’empêche que je reste persuadé que ce qui est écrit dans l'ouvrage citée plus haut est faux.

Ce qu'il faut retenir :
Le type string est un type référence qui se comporte comme un type valeur.
Source : http://plasserre.developpez.com/cour...age-vb4#LV-K-5.

Edit : @Rasorflak : pas grave, j'aurais appris le terme Primitif queje ne connaissais pas.

[BasicZX81]

Pour revenir au sujet principale qui est le passage de paramètres de Form1 à Form2, j'ai trouvé une autre solution.
Mon 1er exemple ne fonctionnait pas en passant un string par référence dans le constructeur, c'est à dire que les modifications effectuées dans Form1 n'était pas répercutés dans Form2 malgré le mot clé ByRef. La cause étant que les string ne se comporte pas comme des types références.
J'ai donc remplacé le Paramètre String par un objet. Ainsi en passant cet objet comme paramètre et par référence. Les changements effectués sur cet objet depuis Form1 sont bien répercutés dans Form2.
L’inconvénient par rapport à la solution avec les Property c'est que l'on ne peux pas exécuter de code dans Form2 lors d'un changement sur l'objet Paramétre (pour par exemple rafraîchir un Textbox). J'ai donc rajouté un event dans la classe1, il suffit de s'abonner à l'event dans Form2 pour être notifié d'un changement, on peux faire la même chose dans Form1.

Voici le code :
Classe 1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Public Class Params
    Event ValueChanged(ByVal PropertyName As String, ByVal Value As Object)
    Private _Param1 As String
    Public Property Param1() As String
        Get
            Return _Param1
        End Get
        Set(ByVal value As String)
            _Param1 = value
            RaiseEvent ValueChanged("Param1", value)
        End Set
    End Property
 
End Class

Form1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Public Class Form1
    Private Param As New Params
    Public MaForm2 As Form2
    Private Sub Form1_Load(sender As Object, e As System.EventArgs) Handles Me.Load
        MaForm2 = New Form2(Param)
 
        AddHandler Param.ValueChanged, AddressOf RefreshData
    End Sub
    Private Sub RefreshData(ByVal PropertyName As String, Value As Object)
        MessageBox.Show("Message de Form1 : La valeur " & PropertyName & " a changé : " & Value.ToString)
    End Sub
    Private Sub TextBoxParamétre_TextChanged(sender As System.Object, e As System.EventArgs) Handles TextBoxParamètre.TextChanged
        Param.Param1 = TextBoxParamètre.Text
    End Sub
    Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles ButtonShoxForm2.Click
 
        MaForm2.Show()
    End Sub
End Class

Form2 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Public Class Form2
    Private _Param As Params
    Public Sub New()
 
        ' Cet appel est requis par le concepteur.
        InitializeComponent()
 
        ' Ajoutez une initialisation quelconque après l'appel InitializeComponent().
    End Sub
    Public Sub New(ByRef Param As Params)
        Call Me.New()
        ' Ajoutez une initialisation quelconque après l'appel InitializeComponent().
        _Param = Param
    End Sub
 
    Private Sub Form2_FormClosing(sender As Object, e As System.Windows.Forms.FormClosingEventArgs) Handles Me.FormClosing
        Me.Hide()
        e.Cancel = True
    End Sub
 
    Private Sub Form2_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
 
        AddHandler _Param.ValueChanged, AddressOf RefreshData
    End Sub
    Private Sub RefreshData(ByVal PropertyName As String, Value As Object)
        MessageBox.Show("Message de Form2 : La valeur " & PropertyName & " a changé : " & Value.ToString)
        TextBoxParamètre.Text = _Param.Param1
    End Sub
 
End Class

J'ai donc 2 solutions :
Solution avec les Property : Je n'ai pas besoin de Variable Objet Public comme paramètre. Je travail directement sur une instance de Form2 et je passe le paramétre dans Property de Form2. Je peux exécuter du code dés qu'une modification de la Property est effectuée.

Solution avec un objet Public : Je travail sur une instance de l'objet Param. Les modifications sont répercutés dans Form2 car l'objet est passé par référence. Je peux exécuter du code dés que l'objet Param est modifié en m'abonnent à l'évent "ValueChanged".

J’hésite encore a utiliser l'une ou l'autre solution. Je pense que mon choix se fera suivant si j'ai besoin d'un objet Public ou pas je pense.
Je me pose aussi la question de savoir si j'ai bien fait d'utiliser une variable Objet dans l'event "ValueChanged" .
N’hésitez pas si vous avez des propositions ou des améliorations a apporter.