Come fare in modo che una finestra rimanga sempre in primo piano in .Net?

Ho un'app winforms C # che esegue una macro in un altro programma. L'altro programma aprirà continuamente finestre e generalmente farà sembrare le cose, in mancanza di una parola migliore, pazze. Voglio implementare un pulsante Annulla che interromperà l'esecuzione del processo, ma non riesco a far sì che la finestra rimanga in primo piano. Come si esegue questa operazione in C #?

Modifica: ho provato TopMost = true; , ma l'altro programma continua a far apparire le proprie finestre sopra. C'è un modo per inviare la mia finestra in alto ogni n millisecondi?

Modifica: il modo in cui ho risolto questo problema è stato aggiungendo un'icona nella barra delle applicazioni che annullerà il processo facendo doppio clic su di essa. L'icona della barra delle applicazioni non viene coperta. Grazie a tutti coloro che hanno risposto. Ho letto l'articolo sul motivo per cui non esiste una finestra "super-in-top" ... logicamente non funziona.

Form.TopMost funzionerà a meno che l'altro programma non crei le finestre più in alto.

Non è possibile creare una finestra che non sia coperta dalle nuove finestre più in alto di un altro processo. Raymond Chen ha spiegato perché.

Stavo cercando di rendere la mia applicazione WinForms "Sempre in primo piano", ma l'impostazione "TopMost" non ha fatto nulla per me. Sapevo che era possibile perché WinAmp lo fa (insieme a una miriade di altre applicazioni).

Quello che ho fatto è stato chiamare "user32.dll". Non ho avuto remore a farlo e funziona benissimo. Comunque è un'opzione.

Innanzitutto, importa il seguente spazio dei nomi:

using System.Runtime.InteropServices;

Aggiungi alcune variabili alla tua dichiarazione di classe:

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;

Aggiungi prototipo per la funzione 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);

Quindi nel tuo codice (ho aggiunto la chiamata in Form_Load ()), aggiungi la chiamata:

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

Spero che aiuti. Riferimento

Se per "impazzire" intendi che ogni finestra continua a rubare il focus dall'altra, TopMost non risolverà il problema.

Prova invece:

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

Questo mostrerà la forma "bambino" senza che rubi il focus. Il modulo figlio rimarrà anche sopra il suo genitore anche se il genitore è attivato o focalizzato. Questo codice funziona facilmente solo se hai creato un'istanza del modulo figlio dall'interno del modulo del proprietario. In caso contrario, potresti dover impostare il proprietario utilizzando l'API.

Imposta Form.TopMost

Ho avuto un momentaneo intervallo di 5 minuti e ho dimenticato di specificare il modulo per intero in questo modo:

  myformName.ActiveForm.TopMost = true;

Ma quello che volevo davvero era QUESTO!

  this.TopMost = true;

Imposta la .TopMostproprietà del modulo su true.

Probabilmente non vuoi lasciarlo sempre in questo modo: impostalo quando inizia il tuo processo esterno e rimettilo a posto quando finisce.

Il modo in cui ho risolto questo problema è stato creando un'icona nella barra delle applicazioni con un'opzione di annullamento.

Il codice seguente fa in modo che la finestra rimanga sempre in primo piano e la rende senza cornice.

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

Qual è l'altra applicazione di cui stai cercando di sopprimere la visibilità? Hai studiato altri modi per ottenere l'effetto desiderato? Per favore, fallo prima di sottoporre i tuoi utenti a comportamenti canaglia come stai descrivendo: quello che stai cercando di fare suona piuttosto come quello che fanno certi siti cattivi con le finestre del browser ...

Almeno cerca di aderire alla regola della minima sorpresa . Gli utenti si aspettano di essere in grado di determinare da soli l'ordine z della maggior parte delle applicazioni. Non sai cosa è più importante per loro, quindi se cambi qualcosa, dovresti concentrarti sul portare l'altra applicazione dietro tutto piuttosto che promuovere la tua.

Questo è ovviamente più complicato, poiché Windows non ha un gestore di finestre particolarmente sofisticato. Due approcci si suggeriscono:

1. enumerando le finestre di primo livello e controllando a quale processo appartengono , eliminando il loro ordine z in caso affermativo . (Non sono sicuro che esistano metodi framework per queste funzioni WinAPI.)
2. Giocherellare con le autorizzazioni del processo figlio per impedirgli di accedere al desktop ... ma non lo proverei fino a quando l'altro approccio non è fallito, poiché il processo figlio potrebbe finire in uno stato zombie mentre richiede l'interazione dell'utente.

Perché non rendere il tuo modulo una finestra di dialogo:

myForm.ShowDialog();

Ecco l'equivalente SetForegroundWindow:

form.Activate();

Ho visto persone fare cose strane come:

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

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

So che è vecchio, ma non ho visto questa risposta.

Nella finestra (xaml) aggiungi:

Deactivated="Window_Deactivated"

Nel codice sottostante per Window_Deactivated:

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

Ciò manterrà la tua finestra in primo piano.

Sulla base di clamum risposta, e di Kevin Vuilleumier commento circa l'altra bandiera responsabili del comportamento, ho fatto questa commutazione che commuta tra on-top e non on-top con pressione di un pulsante.

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