Pai de controle de usuário WPF

Eu tenho um controle de usuário que carrego em um MainWindowtempo de execução. Não consigo identificar a janela que contém o arquivo UserControl.

Eu tentei this.Parent, mas é sempre nulo. Alguém sabe como obter um identificador para a janela que contém de um controle de usuário no WPF?

Aqui está como o controle é carregado:

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

Tente usar o seguinte:

Window parentWindow = Window.GetWindow(userControlReference);

o GetWindow método guiará o VisualTree para você e localizará a janela que hospeda seu controle.

Você deve executar esse código após o carregamento do controle (e não no construtor Window) para impedir que o GetWindowmétodo retorne null. Por exemplo, conecte um evento:

this.Loaded += new RoutedEventHandler(UserControl_Loaded); 

Vou adicionar minha experiência. Embora o uso do evento Loaded possa fazer o trabalho, acho que pode ser mais adequado substituir o método OnInitialized. Carregado ocorre depois que a janela é exibida pela primeira vez. OnInitialized oferece a chance de fazer alterações, por exemplo, adicionar controles à janela antes que ela seja renderizada.

Tente usar VisualTreeHelper.GetParent ou use a função recursiva abaixo para encontrar a janela pai.

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

Eu precisava usar o método Window.GetWindow (this) no manipulador de eventos Loaded. Em outras palavras, usei a resposta de Ian Oakes em combinação com a resposta de Alex para obter o pai de um controle de usuário.

public MainView()
{
    InitializeComponent();

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

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

    ...
}

Essa abordagem funcionou para mim, mas não é tão específica quanto sua pergunta:

App.Current.MainWindow

Se você está encontrando essa pergunta e o VisualTreeHelper não está funcionando para você ou esporadicamente, pode ser necessário incluir o LogicalTreeHelper no seu algoritmo.

Aqui está o que eu estou 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);
}

Que tal agora:

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

Descobri que o pai de um UserControl é sempre nulo no construtor, mas em qualquer manipulador de eventos o pai está definido corretamente. Eu acho que deve ter algo a ver com a maneira como a árvore de controle é carregada. Portanto, para contornar isso, basta obter o pai no evento Controles Carregados.

Para um exemplo de checkout, esta pergunta DataContext do WPF User Control é Nulo

Outra maneira:

var main = App.Current.MainWindow as MainWindow;

Está funcionando para mim:

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

Isso não funcionou para mim, pois subiu demais na árvore e obteve a janela raiz absoluta para todo o aplicativo:

Window parentWindow = Window.GetWindow(userControlReference);

No entanto, isso funcionou para obter a janela imediata:

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

Edição banhada a ouro das opções acima (eu preciso de uma função genérica que possa inferir a Windowdentro do contexto de uma 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á corretamente uma janela na seguinte base:

• a raiz Windowpercorrendo a árvore visual (se usada no contexto de umUserControl )
• a janela na qual é usada (se for usada no contexto da Windowmarcação de uma)

Diferentes abordagens e estratégias diferentes. No meu caso, não consegui encontrar a janela da minha caixa de diálogo usando o VisualTreeHelper ou os métodos de extensão da Telerik para encontrar o pai de um determinado tipo. Em vez disso, encontrei minha exibição na minha caixa de diálogo, que aceita injeção personalizada de conteúdo usando Application.Current.Windows.

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

O Window.GetWindow(userControl)retornará a janela real somente após a janela foi inicializado (InitializeComponent() método acabado).

Isso significa que, se o controle do usuário for inicializado junto com a janela (por exemplo, você coloca o controle do usuário no arquivo xaml da janela), no OnInitializedevento do controle do usuário você não receberá a janela (será nula), pois causa Nesse caso, o controle do usuárioOnInitialized evento acionado antes da janela ser inicializada.

Isso também significa que, se o controle do usuário for inicializado após a janela, você poderá obter a janela já no construtor do controle do usuário.

Se você deseja apenas obter um pai específico, não apenas a janela, um pai específico na estrutura da árvore e também não usar contadores de recursão ou loop de interrupção, você pode usar o seguinte:

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

Apenas não faça essa chamada em um construtor (já que a Parentpropriedade ainda não foi inicializada). Adicione-o no manipulador de eventos de carregamento ou em outras partes do seu aplicativo.