Discussion :

[martialv02]

Bonjour,

Après plusieurs jours, je n'arrive pas à lancer une fonction de la Window1 à partir de la Window2. En VB, j'avais l'habitude de déclarer la fonction public et tout fonctionnait.

En C# WPF, il est très difficile de transférer des commandes entre les classes d'une fenêtre différente.

Plusieurs parlent de MVVM ou Events ou Icommand. j'aimerais bien avoir des détails pour le faire ou un code source de deux fenêtres (non parent-enfant) qui échangent des commandes.

Merci à l'avance!

[Pol63]

en vb6 il y avait surtout des modules, donc tout pouvait être appelé de partout
un module étant équivalant à une classe static

en .net les fenetres sont des classes, donc pour pouvoir utiliser un membre public d'une classe il faut une instance
comme pour faire unbouton.IsEnabled = False tu as une variable unbouton de type Button
donc pour appeler une méthode de window1 depuis window2 il te faut une instance
une des possibilités est de faire pour window2 un constructeur qui demande une instance de window1 en paramètre, que tu ranges dans une variable privée


après sur le fond tu fais surement fausse route, en wpf l'interface et le code doivent être dissociés (enfin normalement)
c'est donc aux classes de données d'avoir des méthodes, et l'interface les appelle (par le relaycommand par exemple)
si 2 fenetres doivent avoir des infos communes, les instances doivent être les mêmes, comme ca en cas de changement de valeur (et ce qu'il faut pour avertir l'interface entre inotifypropertychanged et les dependencyobjet) les 2 fenetres seront mises à jour

[chrisdot]

Je pense que la difficulté réside dans la question "comment la window2 identifie la window1?" (peut être même son existence) ...?? Est-ce que la window1 existe toujours lorsque la window2 est créée, etc... (au fait c'est pas du modal, hein?)
Je n'ai pas ces éléments, mais à priori, je dirait qu'il faudrait être indépendant de toutes ces questions... Du coup je pense à un système d'évènements (genre event C#) ou messagerie plus haut niveau (du style event aggregator comme dans mvvmlight)...
Comme ça lorsque window2 a envie d'envoyer son message elle n'a pas à se préoccuper de l'existence de window1... Et window1 devra s'enregistrer sur la réception de ce(s) message(s) lors de sa création...
Je t'encourage à jeter un œil à des librairies du type mvvmLight si tu fais du WPF, y'a plein de petites choses sympas dedans.

[MABROUKI]

bonjour

La class app en code behind est faite pour ca ....puisque c'est elle qui gere toutes les fenetres d'applicatiion...
Le mainwindow peux gerer un list<form>(ou plusieurs) dedans et acceder à chaque form de la liste
Chaque form peut par ailleurs se refer à son owner (le mainwindow)...
Ainsi le maindow a le controle total sur la liste des fenetres crees .De plus comme le mainwindow est charge de fermer l'application ceci garandit la destruction de la liste de fenetre ...

1/ exemple sette le content de chacun des forms cree:
code behind .cs de app.xaml:

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
 
using System;
using System.Windows;
using System.Collections.Generic;
 
namespace WindowTracker
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
 
    public partial class App : Application
    {
        private List<Document> documents = new List<Document>();
 
        public List<Document> Documents
        {
            get { return documents; }
            set { documents = value; }
        }
 
    }
}

code xaml d'un form type Document du list<document>:

Code :

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

1
2
3
4
5
6
7
8
 
<Window x:Class="WindowTracker.Document"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WindowTracker" Height="78" Width="209"
    >
    A new document.
</Window>

code .cs du form type Document :

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
 
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
 
namespace WindowTracker
{
    /// <summary>
    /// Interaction logic for Document.xaml
    /// </summary>
 
    public partial class Document : Window
    {
        public Document()
        {
            InitializeComponent();
        }
 
        public void SetContent(string content)
        {
            this.Content = content;
        }
    }
}

code xaml du mainwindow utilisateur:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
<Window x:Class="WindowTracker.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="WindowTracker" Height="300" Width="300"
    >
    <StackPanel>
      <Button Click="cmdCreate_Click" Margin="10,10,10,5" Name="cmdCreate">Click to Create a Document</Button>
      <Button Click="cmdUpdate_Click" Margin="10,5,10,10" Name="cmdUpdate">Click to Refresh the Documents</Button>
    </StackPanel>
</Window>

code .cs du du mainwindow:

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
33
34
35
36
37
38
39
40
41
42
 
 
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
 
 
namespace WindowTracker
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
 
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
 
        private void cmdCreate_Click(object sender, RoutedEventArgs e)
        {
            Document doc = new Document();
            doc.Owner = this;
            doc.Show();
            ((App)Application.Current).Documents.Add(doc);
        }
 
        private void cmdUpdate_Click(object sender, RoutedEventArgs e)
        {
            foreach (Document doc in ((App)Application.Current).Documents)
            {
                doc.SetContent("Refreshed at " + DateTime.Now.ToLongTimeString() + ".");
            }            
        }
    }
}

rien n'empeche par ailleurs d'acceder aux controls d'une instance Documents par exemple si le 1er document de la liste contient un button dans un grid (au lieu que tout son content soit sette par un method) :
xaml du 1er document :

Code :

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

1
2
3
4
5
6
7
 
 <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="auto"></RowDefinition>
         </Grid.RowDefinitions>
        <Button x:Name="btn" Content="button"></Button>
 </Grid>

Et dans le code behind du bouton cmdUpdate du mainwindow on peut ecrire:

Code :

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

1
2
3
4
5
6
7
 
  private void cmdUpdate_Click(object sender, RoutedEventArgs e)
  {
 
            Document doc1 = ((App)Application.Current).Documents[0];
            doc1.btn.Background = Brushes.Yellow;
       }

bon code....

[martialv02]

Merci pour vos réponses, après plusieurs jours de recherche, j’ai trouvé ce que je cherchais.

Voilà :
J’ouvre la fenêtre 2 et j’appelle la fonction « callModify » de la fenêtre principale pour modifier le texte.