¿Cómo hacer que una ventana permanezca siempre arriba en .Net?

Tengo una aplicación C # winforms que ejecuta una macro en otro programa. El otro programa continuamente abrirá ventanas y, en general, hará que las cosas se vean, a falta de una palabra mejor, loca. Quiero implementar un botón de cancelación que detendrá la ejecución del proceso, pero parece que no puedo hacer que la ventana permanezca en la parte superior. ¿Cómo hago esto en C #?

Editar: he probado TopMost = true; , pero el otro programa sigue apareciendo sus propias ventanas en la parte superior. ¿Hay alguna manera de enviar mi ventana a la parte superior cada n milisegundos?

Editar: La forma en que resolví esto fue agregando un ícono de la bandeja del sistema que cancelará el proceso al hacer doble clic en él. El icono de la bandeja del sistema no se cubre. Gracias a todos los que respondieron. Leí el artículo sobre por qué no hay una ventana 'súper en la parte superior' ... lógicamente no funciona.

Form.TopMost funcionará a menos que el otro programa esté creando las ventanas superiores.

No hay forma de crear una ventana que no esté cubierta por las nuevas ventanas superiores de otro proceso. Raymond Chen explicó por qué.

Estaba buscando hacer mi aplicación WinForms "Always on Top" pero configurar "TopMost" no hizo nada por mí. Sabía que era posible porque WinAmp hace esto (junto con muchas otras aplicaciones).

Lo que hice fue llamar a "user32.dll". No tuve reparos en hacerlo y funciona muy bien. De todos modos, es una opción.

Primero, importe el siguiente espacio de nombres:

using System.Runtime.InteropServices;

Agregue algunas variables a su declaración de clase:

private static readonly IntPtr HWND_TOPMOST = new IntPtr(-1);
private const UInt32 SWP_NOSIZE = 0x0001;
private const UInt32 SWP_NOMOVE = 0x0002;
private const UInt32 TOPMOST_FLAGS = SWP_NOMOVE | SWP_NOSIZE;

Agregue un prototipo para la función user32.dll:

[DllImport("user32.dll")] 
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

Luego, en su código (agregué la llamada en Form_Load ()), agregue la llamada:

SetWindowPos(this.Handle, HWND_TOPMOST, 0, 0, 0, 0, TOPMOST_FLAGS);

Espero que ayude. Referencia

Si por "volverse loco" quiere decir que cada ventana sigue robando el foco a la otra, TopMost no resolverá el problema.

En su lugar, intente:

CalledForm.Owner = CallerForm;
CalledForm.Show();

Esto mostrará la forma 'infantil' sin que robe el foco. El formulario secundario también permanecerá encima de su padre incluso si el padre está activado o enfocado. Este código solo funciona fácilmente si ha creado una instancia del formulario secundario desde el formulario del propietario. De lo contrario, es posible que deba establecer el propietario mediante la API.

Establecer Form.TopMost

Tuve un lapso momentáneo de 5 minutos y olvidé especificar el formulario completo de esta manera:

  myformName.ActiveForm.TopMost = true;

¡Pero lo que realmente quería era ESTO!

  this.TopMost = true;

Establezca la .TopMostpropiedad del formulario en verdadero.

Probablemente no quiera dejarlo así todo el tiempo: configúrelo cuando comience su proceso externo y vuelva a colocarlo cuando termine.

La forma en que resolví esto fue creando un ícono en la bandeja del sistema que tenía una opción de cancelación.

El siguiente código hace que la ventana siempre permanezca en la parte superior y que no tenga marcos.

using System;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace StayOnTop
{
    public partial class Form1 : Form
    {
        private static readonly IntPtr HWND_TOPMOST = new IntPtr(-1);
        private const UInt32 SWP_NOSIZE = 0x0001;
        private const UInt32 SWP_NOMOVE = 0x0002;
        private const UInt32 TOPMOST_FLAGS = SWP_NOMOVE | SWP_NOSIZE;

        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

        public Form1()
        {
            InitializeComponent();
            FormBorderStyle = FormBorderStyle.None;
            TopMost = true;
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            SetWindowPos(this.Handle, HWND_TOPMOST, 100, 100, 300, 300, TOPMOST_FLAGS);
        }

        protected override void WndProc(ref Message m)
        {
            const int RESIZE_HANDLE_SIZE = 10;

            switch (m.Msg)
            {
                case 0x0084/*NCHITTEST*/ :
                    base.WndProc(ref m);

                    if ((int)m.Result == 0x01/*HTCLIENT*/)
                    {
                        Point screenPoint = new Point(m.LParam.ToInt32());
                        Point clientPoint = this.PointToClient(screenPoint);
                        if (clientPoint.Y <= RESIZE_HANDLE_SIZE)
                        {
                            if (clientPoint.X <= RESIZE_HANDLE_SIZE)
                                m.Result = (IntPtr)13/*HTTOPLEFT*/ ;
                            else if (clientPoint.X < (Size.Width - RESIZE_HANDLE_SIZE))
                                m.Result = (IntPtr)12/*HTTOP*/ ;
                            else
                                m.Result = (IntPtr)14/*HTTOPRIGHT*/ ;
                        }
                        else if (clientPoint.Y <= (Size.Height - RESIZE_HANDLE_SIZE))
                        {
                            if (clientPoint.X <= RESIZE_HANDLE_SIZE)
                                m.Result = (IntPtr)10/*HTLEFT*/ ;
                            else if (clientPoint.X < (Size.Width - RESIZE_HANDLE_SIZE))
                                m.Result = (IntPtr)2/*HTCAPTION*/ ;
                            else
                                m.Result = (IntPtr)11/*HTRIGHT*/ ;
                        }
                        else
                        {
                            if (clientPoint.X <= RESIZE_HANDLE_SIZE)
                                m.Result = (IntPtr)16/*HTBOTTOMLEFT*/ ;
                            else if (clientPoint.X < (Size.Width - RESIZE_HANDLE_SIZE))
                                m.Result = (IntPtr)15/*HTBOTTOM*/ ;
                            else
                                m.Result = (IntPtr)17/*HTBOTTOMRIGHT*/ ;
                        }
                    }
                    return;
            }
            base.WndProc(ref m);
        }

        protected override CreateParams CreateParams
        {
            get
            {
                CreateParams cp = base.CreateParams;
                cp.Style |= 0x20000; // <--- use 0x20000
                return cp;
            }
        }
    }
}

¿Cuál es la otra aplicación cuya visibilidad está intentando suprimir? ¿Ha investigado otras formas de lograr el efecto deseado? Hágalo antes de someter a sus usuarios a un comportamiento deshonesto como el que está describiendo: lo que está tratando de hacer suena más bien a lo que ciertos sitios traviesos hacen con las ventanas del navegador ...

Al menos trata de adherirte a la regla de la menor sorpresa . Los usuarios esperan poder determinar el orden z de la mayoría de las aplicaciones por sí mismos. No sabes qué es lo más importante para ellos, así que si cambias algo, debes concentrarte en impulsar la otra aplicación detrás de todo en lugar de promocionar la tuya propia.

Por supuesto, esto es más complicado, ya que Windows no tiene un administrador de ventanas particularmente sofisticado. Se sugieren dos enfoques:

1. enumerando las ventanas de nivel superior y verificando a qué proceso pertenecen , descartando su orden z si es así . (No estoy seguro de si existen métodos de marco para estas funciones de WinAPI).
2. Jugando con los permisos del proceso hijo para evitar que acceda al escritorio ... pero no intentaría esto hasta que el otro enfoque fallara, ya que el proceso hijo podría terminar en un estado zombie y requerir la interacción del usuario.

¿Por qué no convertir su formulario en un cuadro de diálogo?

myForm.ShowDialog();

Aquí está el equivalente de SetForegroundWindow:

form.Activate();

He visto gente haciendo cosas raras como:

this.TopMost = true;
this.Focus();
this.BringToFront();
this.TopMost = false;

http://blog.jorgearimany.com/2010/10/win32-setforegroundwindow-equivalent-in.html

Sé que esto es antiguo, pero no vi esta respuesta.

En la ventana (xaml) agregue:

Deactivated="Window_Deactivated"

En el código detrás de Window_Deactivated:

private void Window_Deactivated(object sender, EventArgs e)
    {
        Window window = (Window)sender;
        window.Activate();
    }

Esto mantendrá su ventana en la parte superior.

Basándome en la respuesta de clamum y el comentario de Kevin Vuilleumier sobre la otra bandera responsable del comportamiento, hice este interruptor que cambia entre arriba y no arriba con solo presionar un botón.

private void button1_Click(object sender, EventArgs e)
    {
        if (on)
        {
            button1.Text = "yes on top";
            IntPtr HwndTopmost = new IntPtr(-1);
            SetWindowPos(this.Handle, HwndTopmost, 0, 0, 0, 0, TopmostFlags);
            on = false;
        }
        else
        {
            button1.Text = "not on top";
            IntPtr HwndTopmost = new IntPtr(-2);
            SetWindowPos(this.Handle, HwndTopmost, 0, 0, 0, 0, TopmostFlags);
            on = true;
        }
    }