Wie man eine statische Referenz auf ein WPF-Fenster?

Habe ich versucht, eine riesige Menge von Möglichkeiten, um einen statischen Verweis von meinem Fenster in mein Programm. Ich brauche Zugriff auf alle seine Mitglieder zur Laufzeit aus verschiedenen Klassen, so dass eine statische Referenz benötigt wird.

Was ich möchte, ist so etwas wie Program.Window1, wo Core ist statisch und MyWindow ist eines Ihrer statischen Mitglieder.

In WinForms, ich in der Regel erklären, meine statischen form im Programm.cs, aber das scheint nicht zu funktionieren mit WPF und Ihre eigene "App.xaml" ApplicationDefinition.

Wie kann ich es tun?

Hinweis: ich habe versucht eine Reihe von Möglichkeiten bereits: mit einem direkten Aufruf ein neues Fenster (d.h. Program.Window1 = new Window1()) wird nicht funktionieren, da ich einige thread Nichtigkeit Ausnahme. So wie ich das bisher verstehe, nur ApplicationDefinitions können, starten Sie windows im WPF.

Hier ist die Ausnahme, wenn ich versuche, ein Fenster zu erstellen ", indem Sie code" und nicht von der Standard-XAML-ApplicationDefinition die StartupUri:

Den aufrufenden thread muss STA, weil viele UI-Komponenten dies erfordern.

Sie haben, um mark Main-Methode mit [STAThread] wenn Sie brauchen, um zu erstellen Sie windows in code.

InformationsquelleAutor Lazlo | 2010-02-13

c#reference static window wpf

11

Erstellen Sie eine statische Klasse, die enthalten kann, die das window-Objekt, und dann, wenn das Fenster erstellt ist, haben Sie es übergeben sich die statische Klasse, von der dann auf die statische Klasse kann die hand aus dem Fenster-Objekt für Interessenten, obwohl das Fenster-Objekt selbst ist nicht statisch. So etwas wie dieses. Es gibt keine Notwendigkeit, Ihre form zu statisch sein, Sie brauchen nur ein statischer Ort, um zu halten das form-Objekt.
```
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; } }
}
```
InformationsquelleAutor John Knoeller
5

Versuchen, diese ((MainWindow)App.Aktuelle.Windows[0]).MainCanvas.

InformationsquelleAutor Developer
4

Es ist durchaus möglich, instanziieren Sie Ihre eigenen windows mit WPF. Aber ja, man hätte auf die "UI-thread" (das ist ein STA-thread).

Zum Beispiel, sagen, wir würden gerne eine Immobilie auf unserer App Klasse, macht einige Fenster.
```
    public partial class App
    {
        private static Window _myWindow;

        public static Window1 MyWindow
        {
            get
            {
                if (_myWindow == null)
                    _myWindow = new Window1();
                return _myWindow;
            }
       }
    }
```
Das problem bei diesem code ist, wie Sie erfahren haben, je nachdem, was thread ist, das aufrufen der MeinFenster getter, new Window1() wird scheitern, wenn den thread nicht ein STA.

Um sicherzustellen, dass die Fenster erzeugt, auf den richtigen thread, geben Sie das Dispatcher-Objekt. Dieses Objekt ist in WPF verwendet, um sicherzustellen, dass die Kommunikation zwischen UI-Elemente erfolgt auf den richtigen thread.

Zurück zu unserem new Window1 wir können die App verwenden.Dispatcher-Objekt, um sicherzustellen, dass die new Betrieb erfolgt auf der Hauptanwendungs-thread, wie diesem:
```
        public static Window1 MyWindow
        {
            get
            {
                if (_myWindow == null)
                {
                     var window = 
                             Application.Current.Dispatcher.Invoke(
                               new Func<Window1>(() => new Window1()));

                    _myWindow = (Window1)window;
                }

                return _myWindow;
            }
       }
```
Hier habe ich in den Griff bekommen, die der aktuellen Anwendung Dispatcher-Objekt und ruft Invoke mit einer Stellvertretung, die die tatsächliche newing. Invoke sorgt dafür, dass meine Stellvertretung erfolgt auf der richtige thread, und gibt das Ergebnis zurück. Voila, das Fenster erstellt wird, ohne die gefürchteten STA Fehler.

Nun, was Sie berücksichtigen müssen ist, dass weitere Anrufe auf die MeinFenster Instanz muss auch auf den richtigen thread. Um zu vermeiden, verunreinigen Sie Ihren code mit aufrufen zum Disponenten.Aufrufen, könnte es sinnvoll sein, wickeln Sie die window-Instanz hinter einer einfachen API. E. g. eine Show-Methode umgesetzt werden könnte, wie diese, machen Sie sicher, dass Marschall der Show-Aufruf über das Dispatcher-Objekt des Fensters:
```
        public static void ShowMyWindow()
        {
            MyWindow.Dispatcher.Invoke(new Action(MyWindow.Show));
        }
```
- Scheint besser geeignet, aber die oben genannte Methode ist einfacher und tun wird. Danke für deine Antwort obwohl. +1
- Dann ist es gut 🙂 Danke für die Abstimmung!
InformationsquelleAutor Peter Lillevold

Habe ich dieses mit Erfolg. Deklarieren Sie eine statische variable vom Typ Fenster. Dann im Konstruktor des Fensters legen Sie die statische variable "this". Ich habe es überall in der app und es scheint zu funktionieren gut innerhalb statisch oder Instanz-Methoden.

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

        screenMain = this;  //static reference to this.

    }

Zum Beispiel ich bin in der Lage, dies zu tun.

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

InformationsquelleAutor howserss

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.