Comment obtenir une référence statique à une Fenêtre WPF?

J'ai essayé une énorme quantité de façons d'obtenir une référence statique de ma fenêtre en travers de mon programme. J'ai besoin d'accéder à l'ensemble de ses membres au moment de l'exécution de différentes classes, la référence statique est nécessaire.

Ce que j'aimerais avoir, c'est quelque chose comme Program.Window1, où Core est statique et MyWindow est l'un de ses membres statiques.

En WinForms, j'ai l'habitude de déclarer mon formulaire statique dans le Programme.cs, mais cela ne semble pas fonctionner avec WPF et leur coutume "App.xaml" ApplicationDefinition.

Comment puis-je le faire?

Note: j'ai essayé un certain nombre de façons: à l'aide d'un appel direct à une nouvelle fenêtre (c'est à dire Program.Window1 = new Window1()) ne fonctionnera pas, que je reçois du fil d'invalidité exception. Ce que je comprends pour l'instant, seuls ApplicationDefinitions pouvez lancer windows en WPF.

Ici est l'exception chaque fois que j'essaie de créer une fenêtre "code", et non par le défaut de XAML ApplicationDefinition de StartupUri:

Le thread appelant doit être PERSONNEL, parce que de nombreux composants de l'INTERFACE utilisateur, l'exigent.

Vous n'aurez qu'à indiquer la méthode Principale avec [STAThread] si vous avez besoin pour créer des fenêtres dans le code.

OriginalL'auteur Lazlo | 2010-02-13

c#reference static window wpf

11

Créer une classe statique qui peut contenir l'objet de la fenêtre, et puis quand la fenêtre est créée, il faut la passer à la classe statique, à partir de là, la classe statique à la main par la fenêtre de l'objet aux parties intéressées, même si la fenêtre de l'objet lui-même n'est pas statique. Quelque chose comme cela. Il n'est pas nécessaire pour votre forme statique, vous avez juste besoin d'un statique de place pour la tenue de la forme de l'objet.
```
public class Core
{
     internal static MyWindowClass m_Wnd = null;

     //call this when your non-static form is created
     //
     public static void SetWnd(MyWindowClass wnd)
     {
         m_Wnd = wnd;
     }

     public static MyWindow { get { return m_Wnd; } }
}
```
OriginalL'auteur John Knoeller
5

Essayez ceci ((MainWindow)App.Actuel.Windows[0]).MainCanvas.

OriginalL'auteur Academy of Programmer
4

Il est tout à fait possible d'instancier votre propre windows avec WPF. Mais oui, vous devez être sur le "thread d'INTERFACE utilisateur" (qui est un thread STA).

Par exemple, disons que nous aimerions avoir une propriété sur notre Appli classe qui expose certains de la fenêtre.
```
    public partial class App
    {
        private static Window _myWindow;

        public static Window1 MyWindow
        {
            get
            {
                if (_myWindow == null)
                    _myWindow = new Window1();
                return _myWindow;
            }
       }
    }
```
Le problème avec ce code, comme vous l'avez expérimenté, en fonction de ce thread appelle la Mafenêtre getter, new Window1() échouera si le thread n'est pas un STA.

Assurez-vous que la fenêtre est créée sur le fil de droite, entrez l'objet Répartiteur. Cet objet est utilisé tout au long de WPF pour s'assurer que la communication entre les éléments de l'INTERFACE utilisateur est faite sur le bon thread.

De retour à notre new Window1, nous pouvons utiliser l'Application.Objet répartiteur assurez-vous que le new opération est effectuée sur le thread principal de l'application, comme ceci:
```
        public static Window1 MyWindow
        {
            get
            {
                if (_myWindow == null)
                {
                     var window = 
                             Application.Current.Dispatcher.Invoke(
                               new Func<Window1>(() => new Window1()));

                    _myWindow = (Window1)window;
                }

                return _myWindow;
            }
       }
```
Ici, je choppe sur la demande du Répartiteur d'objet et les appels Invoke avec un délégué qui ne le réel newing. Invoke veille à ce que mon délégué est exécutée dans le thread approprié, et retourne le résultat. Voila, la fenêtre est créée sans le redoutable STA erreur.

Maintenant, ce que vous devez avoir à l'esprit que plus les appels effectués sur le Mafenêtre instance doit également être faite sur le bon thread. Pour éviter de salir votre code avec des appels à l'expéditeur.Invoquer, il pourrait être utile pour envelopper la fenêtre exemple derrière une API simple. E. g. un Spectacle méthode pourrait être mis en œuvre comme cela, assurez-vous de l'maréchal de l'appel via le Répartiteur objet de la fenêtre:
```
        public static void ShowMyWindow()
        {
            MyWindow.Dispatcher.Invoke(new Action(MyWindow.Show));
        }
```
Semble plus approprié, mais la méthode ci-dessus est plus simple et ne faire. Merci pour votre réponse. +1
Alors c'est bon 🙂 Merci pour le vote!

OriginalL'auteur Peter Lillevold

J'ai utilisé cela avec succès. Déclarer une variable statique de type de fenêtre. Ensuite, dans le constructeur de la fenêtre définir la variable statique pour "ce". Je l'ai utilisé tout au long de l'application et il semble fonctionner correctement à partir de l'intérieur de statique ou de méthodes d'instance.

    public static MainWindow screenMain = null;
    public MainWindow()
    {
        InitializeComponent();

        screenMain = this;  //static reference to this.

    }

Par exemple, je suis capable de faire cela.

    private delegate void del();
    ....
    screenMain.Dispatcher.Invoke(new del(delegate()
    {
        screenMain.ButtonSubmit.IsEnabled = true;
        screenMain.ButtonPreClearing.IsEnabled = true;
    }));

OriginalL'auteur howserss

Vous devez vous connecter pour publier un commentaire.