WPF User Control Parent

Ich habe ein Benutzersteuerelement, das ich MainWindowzur Laufzeit in ein lade . Ich kann das enthaltende Fenster aus dem nicht in den Griff bekommen UserControl.

Ich habe es versucht this.Parent, aber es ist immer null. Weiß jemand, wie man von einem Benutzersteuerelement in WPF ein Handle auf das enthaltende Fenster bekommt?

So wird das Steuerelement geladen:

private void XMLLogViewer_MenuItem_Click(object sender, RoutedEventArgs e)
{
    MenuItem application = sender as MenuItem;
    string parameter = application.CommandParameter as string;
    string controlName = parameter;
    if (uxPanel.Children.Count == 0)
    {
        System.Runtime.Remoting.ObjectHandle instance = Activator.CreateInstance(Assembly.GetExecutingAssembly().FullName, controlName);
        UserControl control = instance.Unwrap() as UserControl;
        this.LoadControl(control);
    }
}

private void LoadControl(UserControl control)
{
    if (uxPanel.Children.Count > 0)
    {
        foreach (UIElement ctrl in uxPanel.Children)
        {
            if (ctrl.GetType() != control.GetType())
            {
                this.SetControl(control);
            }
        }
    }
    else
    {
        this.SetControl(control);
    }
}

private void SetControl(UserControl control)
{
    control.Width = uxPanel.Width;
    control.Height = uxPanel.Height;
    uxPanel.Children.Add(control);
}

Versuchen Sie Folgendes:

Window parentWindow = Window.GetWindow(userControlReference);

Die GetWindowMethode durchsucht den VisualTree für Sie und sucht das Fenster, in dem sich Ihr Steuerelement befindet.

Sie sollten diesen Code ausführen, nachdem das Steuerelement geladen wurde (und nicht im Window-Konstruktor), um zu verhindern, dass die GetWindowMethode zurückgegeben wird null. ZB ein Ereignis verkabeln:

this.Loaded += new RoutedEventHandler(UserControl_Loaded); 

Ich werde meine Erfahrung hinzufügen. Obwohl die Verwendung des Loaded-Ereignisses den Job erledigen kann, ist es meiner Meinung nach besser geeignet, die OnInitialized-Methode zu überschreiben. Das Laden erfolgt nach der ersten Anzeige des Fensters. Mit OnInitialized können Sie Änderungen vornehmen, z. B. Steuerelemente zum Fenster hinzufügen, bevor es gerendert wird.

Versuchen Sie es mit VisualTreeHelper.GetParent oder verwenden Sie die folgende rekursive Funktion, um das übergeordnete Fenster zu finden.

 public static Window FindParentWindow(DependencyObject child)
    {
        DependencyObject parent= VisualTreeHelper.GetParent(child);

        //CHeck if this is the end of the tree
        if (parent == null) return null;

        Window parentWindow = parent as Window;
        if (parentWindow != null)
        {
            return parentWindow;
        }
        else
        {
            //use recursion until it reaches a Window
            return FindParentWindow(parent);
        }
    }

Ich musste die Window.GetWindow (this) -Methode im Loaded-Ereignishandler verwenden. Mit anderen Worten, ich habe die Antwort von Ian Oakes in Kombination mit der Antwort von Alex verwendet, um die Eltern eines Benutzersteuerelements zu erhalten.

public MainView()
{
    InitializeComponent();

    this.Loaded += new RoutedEventHandler(MainView_Loaded);
}

void MainView_Loaded(object sender, RoutedEventArgs e)
{
    Window parentWindow = Window.GetWindow(this);

    ...
}

Dieser Ansatz hat bei mir funktioniert, ist aber nicht so spezifisch wie Ihre Frage:

App.Current.MainWindow

Wenn Sie diese Frage finden und der VisualTreeHelper nicht oder nur sporadisch für Sie funktioniert, müssen Sie möglicherweise LogicalTreeHelper in Ihren Algorithmus aufnehmen.

Folgendes verwende ich:

public static T TryFindParent<T>(DependencyObject current) where T : class
{
    DependencyObject parent = VisualTreeHelper.GetParent(current);
    if( parent == null )
        parent = LogicalTreeHelper.GetParent(current);
    if( parent == null )
        return null;

    if( parent is T )
        return parent as T;
    else
        return TryFindParent<T>(parent);
}

Wie wäre es damit:

DependencyObject parent = ExVisualTreeHelper.FindVisualParent<UserControl>(this);

public static class ExVisualTreeHelper
{
    /// <summary>
    /// Finds the visual parent.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="sender">The sender.</param>
    /// <returns></returns>
    public static T FindVisualParent<T>(DependencyObject sender) where T : DependencyObject
    {
        if (sender == null)
        {
            return (null);
        }
        else if (VisualTreeHelper.GetParent(sender) is T)
        {
            return (VisualTreeHelper.GetParent(sender) as T);
        }
        else
        {
            DependencyObject parent = VisualTreeHelper.GetParent(sender);
            return (FindVisualParent<T>(parent));
        }
    } 
}

Ich habe festgestellt, dass das übergeordnete Element eines UserControl im Konstruktor immer null ist, aber in jedem Fallhandler ist das übergeordnete Element korrekt festgelegt. Ich denke, es muss etwas mit der Art und Weise zu tun haben, wie der Kontrollbaum geladen wird. Um dies zu umgehen, können Sie das übergeordnete Element im Steuerelement Loaded-Ereignis abrufen.

Als Beispiel für das Auschecken dieser Frage lautet der DataContext von WPF User Control Null

Ein anderer Weg:

var main = App.Current.MainWindow as MainWindow;

Es funktioniert für mich:

DependencyObject GetTopLevelControl(DependencyObject control)
{
    DependencyObject tmp = control;
    DependencyObject parent = null;
    while((tmp = VisualTreeHelper.GetParent(tmp)) != null)
    {
        parent = tmp;
    }
    return parent;
}

Dies funktionierte bei mir nicht, da es zu weit oben im Baum lag und das absolute Stammfenster für die gesamte Anwendung erhielt:

Window parentWindow = Window.GetWindow(userControlReference);

Dies funktionierte jedoch, um das unmittelbare Fenster zu erhalten:

DependencyObject parent = uiElement;
int avoidInfiniteLoop = 0;
while ((parent is Window)==false)
{
    parent = VisualTreeHelper.GetParent(parent);
    avoidInfiniteLoop++;
    if (avoidInfiniteLoop == 1000)
    {
        // Something is wrong - we could not find the parent window.
        break;
    }
}
Window window = parent as Window;
window.DragMove();

DependencyObject parent = ExVisualTreeHelper.FindVisualParent<UserControl>(this);

DependencyObject GetTopParent(DependencyObject current)
{
    while (VisualTreeHelper.GetParent(current) != null)
    {
        current = VisualTreeHelper.GetParent(current);
    }
    return current;
}

DependencyObject parent = GetTopParent(thisUserControl);

Vergoldete Ausgabe des oben genannten (Ich brauche eine generische Funktion, die a Windowim Kontext von a ableiten kann MarkupExtension: -

public sealed class MyExtension : MarkupExtension
{
    public override object ProvideValue(IServiceProvider serviceProvider) =>
        new MyWrapper(ResolveRootObject(serviceProvider));
    object ResolveRootObject(IServiceProvider serviceProvider) => 
         GetService<IRootObjectProvider>(serviceProvider).RootObject;
}

class MyWrapper
{
    object _rootObject;

    Window OwnerWindow() => WindowFromRootObject(_rootObject);

    static Window WindowFromRootObject(object root) =>
        (root as Window) ?? VisualParent<Window>((DependencyObject)root);
    static T VisualParent<T>(DependencyObject node) where T : class
    {
        if (node == null)
            throw new InvalidOperationException("Could not locate a parent " + typeof(T).Name);
        var target = node as T;
        if (target != null)
            return target;
        return VisualParent<T>(VisualTreeHelper.GetParent(node));
    }
}

MyWrapper.Owner() wird ein Fenster auf der folgenden Basis korrekt ableiten:

• die Wurzel Windowdurch Gehen über den visuellen Baum (falls im Kontext von a verwendet UserControl)
• das Fenster, in dem es verwendet wird (wenn es im Kontext des WindowMarkups von a verwendet wird)

Unterschiedliche Ansätze und unterschiedliche Strategien. In meinem Fall konnte ich das Fenster meines Dialogfelds weder mithilfe von VisualTreeHelper noch mithilfe von Erweiterungsmethoden von Telerik finden, um übergeordnete Elemente eines bestimmten Typs zu finden. Stattdessen habe ich meine Dialogansicht gefunden, die das benutzerdefinierte Einfügen von Inhalten mit Application.Current.Windows akzeptiert.

public Window GetCurrentWindowOfType<TWindowType>(){
 return Application.Current.Windows.OfType<TWindowType>().FirstOrDefault() as Window;
}

Das Window.GetWindow(userControl)eigentliche Fenster wird erst zurückgegeben, nachdem das Fenster initialisiert wurde ( InitializeComponent()Methode beendet).

Dies bedeutet, dass, wenn Ihr Benutzersteuerelement zusammen mit seinem Fenster initialisiert wird (z. B. wenn Sie Ihr Benutzersteuerelement in die xaml-Datei des Fensters einfügen), das OnInitializedEreignis beim Ereignis des Benutzersteuerelements nicht angezeigt wird (es ist null) In diesem Fall wird das OnInitializedEreignis des Benutzersteuerelements ausgelöst, bevor das Fenster initialisiert wird.

Dies bedeutet auch, dass Sie das Fenster bereits im Konstruktor des Benutzersteuerelements abrufen können, wenn Ihr Benutzersteuerelement nach seinem Fenster initialisiert wird.