Control de usuario de WPF principal

Tengo un control de usuario que cargo en MainWindowtiempo de ejecución. No puedo obtener un identificador de la ventana que contiene desde el UserControl.

Lo he intentado this.Parent, pero siempre es nulo. ¿Alguien sabe cómo obtener un identificador para la ventana que contiene desde un control de usuario en WPF?

Así es como se carga el control:

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

Intenta usar lo siguiente:

Window parentWindow = Window.GetWindow(userControlReference);

El GetWindowmétodo recorrerá el VisualTree por usted y localizará la ventana que aloja su control.

Debe ejecutar este código después de que el control se haya cargado (y no en el constructor de Windows) para evitar que el GetWindowmétodo regrese null. Por ejemplo, cablear un evento:

this.Loaded += new RoutedEventHandler(UserControl_Loaded); 

Agregaré mi experiencia. Aunque el uso del evento Loaded puede hacer el trabajo, creo que puede ser más adecuado anular el método OnInitialized. La carga se produce después de que la ventana se muestra por primera vez. OnInitialized le brinda la oportunidad de realizar cambios, por ejemplo, agregar controles a la ventana antes de que se procese.

Intente usar VisualTreeHelper.GetParent o use la siguiente función recursiva para encontrar la ventana principal.

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

Necesitaba usar el método Window.GetWindow (this) dentro del controlador de eventos Loaded. En otras palabras, utilicé la respuesta de Ian Oakes en combinación con la respuesta de Alex para obtener un padre de control de usuario.

public MainView()
{
    InitializeComponent();

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

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

    ...
}

Este enfoque funcionó para mí, pero no es tan específico como su pregunta:

App.Current.MainWindow

Si está encontrando esta pregunta y VisualTreeHelper no funciona para usted o no funciona esporádicamente, es posible que deba incluir LogicalTreeHelper en su algoritmo.

Esto es lo que estoy 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);
}

Qué tal esto:

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

Descubrí que el padre de un UserControl siempre es nulo en el constructor, pero en cualquier caso los controladores están configurados correctamente. Supongo que debe tener algo que ver con la forma en que se carga el árbol de control. Entonces, para evitar esto, solo puede obtener el padre en el evento Cargado de controles.

Para ver un ejemplo, consulte esta pregunta el DataContext de WPF User Control es nulo

De otra manera:

var main = App.Current.MainWindow as MainWindow;

Me esta funcionando:

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

Esto no funcionó para mí, ya que subió demasiado el árbol y obtuvo la ventana raíz absoluta para toda la aplicación:

Window parentWindow = Window.GetWindow(userControlReference);

Sin embargo, esto funcionó para obtener la ventana inmediata:

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

Edición chapada en oro de lo anterior (necesito una función genérica que pueda inferir a Windowen el contexto de 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á correctamente una ventana de la siguiente manera:

• la raíz Windowcaminando por el árbol visual (si se usa en el contexto de unUserControl )
• la ventana dentro de la cual se usa (si se usa en el contexto de un Windowmarcado)

Diferentes enfoques y diferentes estrategias. En mi caso, no pude encontrar la ventana de mi cuadro de diálogo mediante el uso de VisualTreeHelper o los métodos de extensión de Telerik para encontrar el padre del tipo dado. En cambio, encontré mi vista de diálogo que acepta la inyección personalizada de contenido usando Application.Current.Windows.

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

El Window.GetWindow(userControl)devolverá la ventana real solo después de que la ventana se haya inicializado ( InitializeComponent()método terminado).

Esto significa que si su control de usuario se inicializa junto con su ventana (por ejemplo, coloca su control de usuario en el archivo xaml de la ventana), entonces, en el OnInitializedevento del control de usuario , no obtendrá la ventana (será nula), porque en ese caso el control del usuarioOnInitialized evento dispara antes de que se inicialice la ventana.

Esto también significa que si su control de usuario se inicializa después de su ventana, puede obtener la ventana ya en el constructor del control de usuario.

Si solo desea obtener un elemento primario específico, no solo la ventana, un elemento primario específico en la estructura de árbol y también no utiliza contadores de recursión o bucle de ruptura dura, puede usar lo siguiente:

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

Simplemente no ponga esta llamada en un constructor (ya que la Parentpropiedad aún no se ha inicializado). Agréguelo en el controlador de eventos de carga o en otras partes de su aplicación.