Genitore controllo utente WPF

Ho un controllo utente che carico in un MainWindowruntime. Non riesco a ottenere un handle sulla finestra contenente dal UserControl.

Ho provato this.Parent, ma è sempre nullo. Qualcuno sa come ottenere un handle per la finestra contenente da un controllo utente in WPF?

Ecco come viene caricato il controllo:

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

Prova a utilizzare quanto segue:

Window parentWindow = Window.GetWindow(userControlReference);

Il GetWindow metodo eseguirà VisualTree per te e individuerà la finestra che ospita il tuo controllo.

È necessario eseguire questo codice dopo che il controllo è stato caricato (e non nel costruttore Window) per impedire il GetWindowritorno del metodo null. Ad esempio, collegare un evento:

this.Loaded += new RoutedEventHandler(UserControl_Loaded); 

Aggiungerò la mia esperienza. Sebbene l'utilizzo dell'evento Loaded possa fare il lavoro, penso che potrebbe essere più adatto a sovrascrivere il metodo OnInitialized. Caricato si verifica dopo la prima visualizzazione della finestra. OnInitialized ti dà la possibilità di apportare modifiche, ad esempio, aggiungere controlli alla finestra prima che venga renderizzata.

Prova a utilizzare VisualTreeHelper.GetParent o usa la seguente funzione ricorsiva per trovare la finestra principale.

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

Avevo bisogno di usare il metodo Window.GetWindow (questo) nel gestore di eventi Loaded. In altre parole, ho usato la risposta di Ian Oakes in combinazione con la risposta di Alex per ottenere il genitore di un controllo utente.

public MainView()
{
    InitializeComponent();

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

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

    ...
}

Questo approccio ha funzionato per me ma non è specifico come la tua domanda:

App.Current.MainWindow

Se trovi questa domanda e VisualTreeHelper non funziona per te o non funziona sporadicamente, potresti dover includere LogicalTreeHelper nel tuo algoritmo.

Ecco cosa sto usando:

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

Cosa ne pensi di questo:

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

Ho scoperto che il genitore di un UserControl è sempre nullo nel costruttore, ma in ogni caso i gestori il genitore è impostato correttamente. Immagino che debba avere qualcosa a che fare con il modo in cui l'albero di controllo viene caricato. Quindi, per ovviare a questo, puoi semplicemente ottenere il genitore nell'evento Loaded controlli.

Per un esempio di checkout questa domanda DataContext di WPF User Control è Null

Un altro modo:

var main = App.Current.MainWindow as MainWindow;

Funziona per me:

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

Questo non ha funzionato per me, poiché è andato troppo in alto nell'albero e ha ottenuto la finestra principale assoluta per l'intera applicazione:

Window parentWindow = Window.GetWindow(userControlReference);

Tuttavia, questo ha funzionato per ottenere la finestra immediata:

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

Edizione placcata in oro di quanto sopra (ho bisogno di una funzione generica che possa inferire a Window nel contesto di un 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() inferirà correttamente una finestra sulla base seguente:

• la radice Windowcamminando sull'albero visivo (se usato nel contesto di aUserControl )
• la finestra all'interno della quale viene utilizzato (se utilizzato nel contesto del Windowmarkup di un)

Approcci diversi e strategie diverse. Nel mio caso non sono riuscito a trovare la finestra della mia finestra di dialogo utilizzando VisualTreeHelper o i metodi di estensione di Telerik per trovare il genitore di un determinato tipo. Invece, ho trovato la mia visualizzazione della mia finestra di dialogo che accetta l'iniezione personalizzata dei contenuti utilizzando Application.Current.Windows.

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

Il Window.GetWindow(userControl)tornerà alla finestra effettiva solo dopo che la finestra è stata inizializzata (InitializeComponent() metodo finito).

Ciò significa che se il controllo utente viene inizializzato insieme alla relativa finestra (ad esempio, si inserisce il controllo utente nel file xaml della finestra), quindi OnInitializedsull'evento del controllo utente non verrà visualizzata la finestra (sarà nulla), perché quel caso è il controllo dell'utenteOnInitialized evento generato prima che la finestra venga inizializzata.

Ciò significa anche che se il controllo utente viene inizializzato dopo la sua finestra, è possibile ottenere la finestra già nel costruttore del controllo utente.

Se vuoi solo ottenere un genitore specifico, non solo la finestra, un genitore specifico nella struttura ad albero e anche non utilizzare contatori di ricorsione o loop di interruzione, puoi utilizzare quanto segue:

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

Basta non inserire questa chiamata in un costruttore (poiché la Parentproprietà non è ancora inizializzata). Aggiungilo nel gestore dell'evento di caricamento o in altre parti dell'applicazione.