WPF User Control Parent

Mam kontrolę użytkownika, którą ładuję do MainWindowśrodowiska wykonawczego. Nie mogę uzyskać uchwytu na okno zawierające z UserControl.

Próbowałem this.Parent, ale zawsze jest nieważne. Czy ktoś wie, jak uzyskać uchwyt do zawierającego okno z kontrolki użytkownika w WPF?

Oto jak ładuje się kontrolkę:

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);
}

Spróbuj użyć następujących opcji:

Window parentWindow = Window.GetWindow(userControlReference);

GetWindowMetoda będzie chodzić VisualTree dla Ciebie i zlokalizuj okno, które jest gospodarzem swoją kontrolę.

Należy uruchomić ten kod po załadowaniu formantu (a nie w konstruktorze Windows), aby zapobiec GetWindowzwróceniu metody null. Np. Zorganizuj zdarzenie:

this.Loaded += new RoutedEventHandler(UserControl_Loaded); 

Dodam moje doświadczenie. Chociaż użycie zdarzenia Loaded może wykonać zadanie, myślę, że bardziej odpowiednie może być zastąpienie metody OnInitialized. Załadowane następuje po pierwszym wyświetleniu okna. OnInitialized daje szansę na dokonanie jakichkolwiek zmian, na przykład dodanie kontrolek do okna przed jego renderowaniem.

Spróbuj użyć VisualTreeHelper.GetParent lub użyj poniższej funkcji rekurencyjnej, aby znaleźć okno nadrzędne.

 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);
        }
    }

Musiałem użyć metody Window.GetWindow (this) w module Loaded event handler. Innymi słowy, użyłem zarówno odpowiedzi Iana Oakesa w połączeniu z odpowiedzią Alexa, aby uzyskać rodzica kontroli użytkownika.

public MainView()
{
    InitializeComponent();

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

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

    ...
}

To podejście działało dla mnie, ale nie jest tak szczegółowe, jak twoje pytanie:

App.Current.MainWindow

Jeśli znajdziesz to pytanie, a VisualTreeHelper nie działa dla ciebie lub działa sporadycznie, może być konieczne włączenie LogicalTreeHelper do algorytmu.

Oto czego używam:

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);
}

Co powiesz na to:

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));
        }
    } 
}

Przekonałem się, że element nadrzędny UserControl jest zawsze pusty w konstruktorze, ale we wszystkich modułach obsługi zdarzeń rodzic jest ustawiony poprawnie. Myślę, że to musi mieć coś wspólnego ze sposobem ładowania drzewa kontrolnego. Aby obejść ten problem, po prostu umieść element nadrzędny w zdarzeniu formantu Loaded.

Na przykład pobranie tego pytania DataContext WPF User Control ma wartość Null

Inny sposób:

var main = App.Current.MainWindow as MainWindow;

Działa dla mnie:

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

Nie działało to dla mnie, ponieważ poszło za daleko w górę drzewa i uzyskało absolutne okno główne dla całej aplikacji:

Window parentWindow = Window.GetWindow(userControlReference);

Jednak działało to, aby uzyskać bezpośrednie okno:

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);

Pozłacane wydanie powyższego (potrzebuję ogólnej funkcji, która może wywnioskować Windoww kontekście 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() poprawnie wnioskuje o oknie na podstawie:

• root Windowprzez chodzenie po drzewie wizualnym (jeśli jest używany w kontekście a UserControl)
• okno, w którym jest używane (jeśli jest używane w kontekście Windowznaczników)

Różne podejścia i różne strategie. W moim przypadku nie mogłem znaleźć okna mojego okna dialogowego za pomocą VisualTreeHelper lub metod rozszerzenia Telerik w celu znalezienia rodzica danego typu. Zamiast tego znalazłem mój widok okna dialogowego, który akceptuje niestandardowe wstrzykiwanie zawartości za pomocą Application.Current.Windows.

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

Window.GetWindow(userControl)Powróci rzeczywistego okna tylko po zamknięciu okna został zainicjowany ( InitializeComponent()metoda zakończona).

Oznacza to, że jeśli twoja kontrola użytkownika zostanie zainicjowana razem z jej oknem (na przykład umieścisz kontrolę użytkownika w pliku xaml okna), to w OnInitializedprzypadku zdarzenia kontroli użytkownika nie otrzymasz okna (będzie puste), ponieważ w takim przypadku OnInitializedzdarzenie kontrolki użytkownika zostanie uruchomione przed zainicjowaniem okna.

Oznacza to również, że jeśli twoja kontrola użytkownika jest zainicjowana po jej oknie, możesz uzyskać okno już w konstruktorze kontroli użytkownika.

Jeśli chcesz uzyskać konkretnego rodzica, nie tylko okno, konkretnego rodzica w strukturze drzewa, a także nie korzystasz z liczników pętli rekurencji lub twardego przerwania, możesz użyć następujących opcji:

public static T FindParent<T>(DependencyObject current)
    where T : class 
{
    var dependency = current;

    while((dependency = VisualTreeHelper.GetParent(dependency) ?? LogicalTreeHelper.GetParent(dependency)) != null
        && !(dependency is T)) { }

    return dependency as T;
}

Po prostu nie umieszczaj tego wywołania w konstruktorze (ponieważ Parentwłaściwość nie została jeszcze zainicjowana). Dodaj go w module obsługi zdarzenia ładowania lub w innych częściach aplikacji.