Traga uma janela para a frente no WPF

214

Como posso trazer meu aplicativo WPF para a frente da área de trabalho? Até agora eu tentei:

SwitchToThisWindow(new WindowInteropHelper(Application.Current.MainWindow).Handle, true);

SetWindowPos(new WindowInteropHelper(Application.Current.MainWindow).Handle, IntPtr.Zero, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

SetForegroundWindow(new WindowInteropHelper(Application.Current.MainWindow).Handle);

Nenhuma delas está realizando o trabalho ( Marshal.GetLastWin32Error()está dizendo que essas operações foram concluídas com êxito e os atributos P / Invoke para cada definição SetLastError=true).

Se eu criar um novo aplicativo WPF em branco e ligar SwitchToThisWindowcom um timer, ele funcionará exatamente como o esperado, portanto, não sei por que ele não está funcionando no meu caso original.

Edit : Eu estou fazendo isso em conjunto com uma tecla de atalho global.

Fator Místico
fonte
Você verificou que o MainWindow é a janela que você deseja? No MSDN: o MainWindow é definido automaticamente com uma referência ao primeiro objeto Window a ser instanciado no AppDomain.
Todd White
Bom pensamento, mas é a única janela no aplicativo.
Factor Mystic
Você pode dar um pouco mais de código de contexto?
Todd White

Respostas:

314
myWindow.Activate();

Tenta trazer a janela para o primeiro plano e a ativa.

Isso deve funcionar, a menos que eu entenda mal e você queira o comportamento Sempre no topo. Nesse caso, você deseja:

myWindow.TopMost = true;
Morten Christiansen
fonte
14
Eu estava simplesmente usando myWindow.Show () e às vezes não estava no topo. Fiz uma chamada para myWindow.Activate () imediatamente depois e funcionou.
Bermo
4
Ativar às vezes não funciona no Windows XP. Eu recomendo a resposta de Matthew Xavier.
Lex Li
Um pouco estranho, já que por padrão ShowActivated está ativado.
Greenoldman 26/05
1
A primeira resposta é boa, obrigado por isso! Mas a segunda linha de código, usar a Topmostpropriedade é uma prática ruim, pois pode ocultar outras caixas de diálogo pop-up e ter um comportamento inesperado.
22614 Jonathan Perry
2
Na verdade, isso pode ser feito com isso: if (myWindow.WindowState == WindowState.Minimized) myWindow.WindowState = WindowState.Normal;Estranhamente, ele também preservará todas as janelas Maximized e não as reverterá para um estado Normal.
R41n
168

Eu encontrei uma solução que traz a janela para o topo, mas se comporta como uma janela normal:

if (!Window.IsVisible)
{
    Window.Show();
}

if (Window.WindowState == WindowState.Minimized)
{
    Window.WindowState = WindowState.Normal;
}

Window.Activate();
Window.Topmost = true;  // important
Window.Topmost = false; // important
Window.Focus();         // important
Jader Dias
fonte
1
Ótima dica! O TopMost faz a mágica acontecer no Windows 7 se a janela já estiver aberta, mas abaixo das outras janelas.
gsb
Isso fez o truque para mim também. Obrigado a gsb pelo comentário adicional sobre o que parece ser um uso estranho do TopMost!
21413 Jen
1
Obrigado - a correção foi curta e agradável.
code4life
2
No meu caso, Window.Activate () e Window.Focus () foram suficientes. Definir Window.TopMost é desnecessário.
virious
6
Não use Window.Focus(). Isso desviará o foco do que o usuário está digitando no momento em uma caixa de texto, o que é extremamente frustrante para os usuários finais. O código acima funciona muito bem sem ele.
Contango 18/03/16
32

Caso você precise que a janela esteja na frente na primeira vez que ela for carregada, use o seguinte:

private void Window_ContentRendered(object sender, EventArgs e)
{
    this.Topmost = false;
}

private void Window_Initialized(object sender, EventArgs e)
{
    this.Topmost = true;
}
Amir
fonte
1
Se você desenvolver algo semelhante ao Launchy ( launchy.net ) em C #, observe que essa resposta é quase inútil.
Lex Li
21

Para tornar este um processo rápido de copiar e colar -
Use esta classe ' DoOnProcessmétodo para mover a janela principal do processo' para o primeiro plano (mas não para roubar o foco de outras janelas)

public class MoveToForeground
{
    [DllImportAttribute("User32.dll")]
    private static extern int FindWindow(String ClassName, String WindowName);

    const int SWP_NOMOVE        = 0x0002;
    const int SWP_NOSIZE        = 0x0001;            
    const int SWP_SHOWWINDOW    = 0x0040;
    const int SWP_NOACTIVATE    = 0x0010;
    [DllImport("user32.dll", EntryPoint = "SetWindowPos")]
    public static extern IntPtr SetWindowPos(IntPtr hWnd, int hWndInsertAfter, int x, int Y, int cx, int cy, int wFlags);

    public static void DoOnProcess(string processName)
    {
        var allProcs = Process.GetProcessesByName(processName);
        if (allProcs.Length > 0)
        {
            Process proc = allProcs[0];
            int hWnd = FindWindow(null, proc.MainWindowTitle.ToString());
            // Change behavior by settings the wFlags params. See http://msdn.microsoft.com/en-us/library/ms633545(VS.85).aspx
            SetWindowPos(new IntPtr(hWnd), 0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOACTIVATE);
        }
    }
}

HTH

Hertzel Guinness
fonte
6
+1 esta é a única resposta que foi útil para mim. Eu tenho um aplicativo com um mestre e várias janelas escravas flutuantes. Ao ativar qualquer uma dessas opções, todas as outras janelas também devem ser trazidas para a frente. Mas não é ativado / ganha o foco, como a maioria das respostas sugere: isso é um desastre, pois torna a janela clicável no momento não clicável, pois de repente outra janela ganha foco.
23711
Alguma razão para não usar process.MainWindowHandle?
Sriram Sakthivel 26/08/14
No meu caso, eu não queria a janela principal, mas concordei que há outras maneiras de obter uma hWnd. FWIW um HwndSourceobjeto funcionou bem.
precisa
21

Sei que essa pergunta é bastante antiga, mas acabei de me deparar com esse cenário preciso e queria compartilhar a solução que implementei.

Conforme mencionado nos comentários desta página, várias das soluções propostas não funcionam no XP, que eu preciso apoiar no meu cenário. Embora eu concorde com o sentimento de @Matthew Xavier de que geralmente essa é uma prática ruim de UX, há momentos em que é uma UX totalmente plausível.

A solução para trazer uma janela WPF para o topo foi realmente fornecida pelo mesmo código que estou usando para fornecer a tecla de atalho global. Um artigo de blog de Joseph Cooney contém um link para seus exemplos de código que contém o código original.

Limpei e modifiquei um pouco o código e o implementei como um método de extensão para System.Windows.Window. Eu testei isso no XP 32 bits e no Win7 64 bits, e ambos funcionam corretamente.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Interop;
using System.Runtime.InteropServices;

namespace System.Windows
{
    public static class SystemWindows
    {
        #region Constants

        const UInt32 SWP_NOSIZE = 0x0001;
        const UInt32 SWP_NOMOVE = 0x0002;
        const UInt32 SWP_SHOWWINDOW = 0x0040;

        #endregion

        /// <summary>
        /// Activate a window from anywhere by attaching to the foreground window
        /// </summary>
        public static void GlobalActivate(this Window w)
        {
            //Get the process ID for this window's thread
            var interopHelper = new WindowInteropHelper(w);
            var thisWindowThreadId = GetWindowThreadProcessId(interopHelper.Handle, IntPtr.Zero);

            //Get the process ID for the foreground window's thread
            var currentForegroundWindow = GetForegroundWindow();
            var currentForegroundWindowThreadId = GetWindowThreadProcessId(currentForegroundWindow, IntPtr.Zero);

            //Attach this window's thread to the current window's thread
            AttachThreadInput(currentForegroundWindowThreadId, thisWindowThreadId, true);

            //Set the window position
            SetWindowPos(interopHelper.Handle, new IntPtr(0), 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW);

            //Detach this window's thread from the current window's thread
            AttachThreadInput(currentForegroundWindowThreadId, thisWindowThreadId, false);

            //Show and activate the window
            if (w.WindowState == WindowState.Minimized) w.WindowState = WindowState.Normal;
            w.Show();
            w.Activate();
        }

        #region Imports

        [DllImport("user32.dll")]
        private static extern IntPtr GetForegroundWindow();

        [DllImport("user32.dll")]
        private static extern uint GetWindowThreadProcessId(IntPtr hWnd, IntPtr ProcessId);

        [DllImport("user32.dll")]
        private static extern bool AttachThreadInput(uint idAttach, uint idAttachTo, bool fAttach);

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

        #endregion
    }
}

Espero que esse código ajude outras pessoas que encontram esse problema.

Zodman
fonte
Ei, olha aí! Eu tenho lutado com isso há meses! Isso funciona para ambas as minhas situações. Impressionante! (Windows 7 x64)
mdiehl13
Na verdade, só parece funcionar se eu fizer isso: App.mainWindow.Show (); SystemWindows.GlobalActivate (App.mainwindow); // Quando eu remover a primeira .mostrar () não traz para a frente
mdiehl13
Com +1 no SetWindowPos (), eu estava procurando uma maneira de trazer minha janela apenas para a frente sem interromper outros aplicativos ou roubar o foco. this.Activate () rouba o foco.
prettyvoid
Isso foi feito para mim e, no meu caso, o objetivo principal era roubar o foco, pois acontecia quando um usuário interagia com determinado elemento. muito obrigado isso parece funcionar de forma consistente! apenas ligar this.Activate()parece funcionar algumas vezes.
Peter Peter
13

Se o usuário estiver interagindo com outro aplicativo, talvez não seja possível trazer o seu para a frente. Como regra geral, um processo só pode esperar definir a janela de primeiro plano se esse processo já for o primeiro plano. (A Microsoft documenta as restrições na entrada do MSDN SetForegroundWindow () .) Isso ocorre porque:

  1. O usuário "possui" o primeiro plano. Por exemplo, seria extremamente irritante se outro programa roubasse o primeiro plano enquanto o usuário digitasse, pelo menos interrompendo seu fluxo de trabalho e possivelmente causando consequências indesejadas, pois as teclas digitadas para um aplicativo são mal interpretadas pelo infrator até que ele note a alteração .
  2. Imagine que cada um dos dois programas verifique se sua janela é o primeiro plano e tente defini-lo como primeiro plano, se não for. Assim que o segundo programa estiver em execução, o computador será inútil à medida que o primeiro plano saltar entre os dois a cada alternância de tarefas.
Matthew Xavier
fonte
Bom ponto. O objetivo do código era em conjunto com uma tecla de atalho global, e outros aplicativos o fazem de alguma maneira.
Factor Mystic
É necessário usar o PInvoke em C # para emular o descrito neste artigo, codeproject.com/Tips/76427/…
Lex Li
então por que a expressão mescla caixas de diálogo pop-up de erro fica visível quando eu alterno para o visual studio às vezes? : - /
Simon_Weaver
Simon, suspeito que os pop-ups de erro que você vê são as janelas "superiores" (uma decisão de design da qual eu desaprovo). Há uma diferença entre a janela do primeiro plano (que recebe entrada do usuário) e uma janela "superior" na ordem Z. Qualquer janela pode ficar "na parte superior", o que a coloca no topo de todas as janelas não na parte superior, mas não dá foco ao teclado da janela, etc., da mesma forma que a janela em primeiro plano.
Matthew Xavier
O truque falha em algumas janelas especiais. O Visual Studio e as janelas do prompt de comando devem ter algo que impeça a outra janela de se tornar a janela do primeiro plano.
Lex Li
9

Eu sei que esta é uma resposta tardia, talvez útil para pesquisadores

 if (!WindowName.IsVisible)
 {
     WindowName.Show();
     WindowName.Activate();
 }
Jamaxack
fonte
9

Por que algumas das respostas desta página estão erradas!

  • Qualquer resposta usada window.Focus()está errada.

    • Por quê? Se uma mensagem de notificação aparecer, window.Focus()o foco será desviado do que o usuário estiver digitando no momento. Isso é insanamente frustrante para os usuários finais, especialmente se os pop-ups ocorrerem com bastante frequência.
  • Qualquer resposta usada window.Activate()está errada.

    • Por quê? Também tornará visível qualquer janela pai.
  • Qualquer resposta que omita window.ShowActivated = falseestá errada.
    • Por quê? Ele irá desviar o foco de outra janela quando a mensagem aparecer, o que é muito chato!
  • Qualquer resposta que não use Visibility.Visible para ocultar / mostrar a janela está errada.
    • Por quê? Se estivermos usando o Citrix, se a janela não for fechada quando fechada, ela deixará uma estranha e retangular retenção preta na tela. Assim, não podemos usar window.Show()e window.Hide().

Essencialmente:

  • A janela não deve desviar o foco de nenhuma outra janela quando for ativada;
  • A janela não deve ativar seu pai quando é mostrada;
  • A janela deve ser compatível com o Citrix.

Solução MVVM

Este código é 100% compatível com o Citrix (sem áreas em branco na tela). É testado com o WPF e o DevExpress normais.

Esta resposta é destinada a qualquer caso de uso em que desejamos uma pequena janela de notificação sempre à frente de outras janelas (se o usuário selecionar isso nas preferências).

Se essa resposta parece mais complexa que as outras, é porque é um código robusto no nível da empresa. Algumas das outras respostas nesta página são simples, mas na verdade não funcionam.

XAML - Propriedade anexada

Adicione esta propriedade anexada a qualquer uma UserControldentro da janela. A propriedade anexada irá:

  • Aguarde até o Loaded evento seja disparado (caso contrário, ele não poderá procurar na árvore visual para encontrar a janela pai).
  • Adicione um manipulador de eventos que garanta que a janela esteja visível ou não.

A qualquer momento, você pode definir a janela para ficar na frente ou não, invertendo o valor da propriedade anexada.

<UserControl x:Class="..."
         ...
         attachedProperties:EnsureWindowInForeground.EnsureWindowInForeground=
             "{Binding EnsureWindowInForeground, Mode=OneWay}">

Método auxiliar

public static class HideAndShowWindowHelper
{
    /// <summary>
    ///     Intent: Ensure that small notification window is on top of other windows.
    /// </summary>
    /// <param name="window"></param>
    public static void ShiftWindowIntoForeground(Window window)
    {
        try
        {
            // Prevent the window from grabbing focus away from other windows the first time is created.
            window.ShowActivated = false;

            // Do not use .Show() and .Hide() - not compatible with Citrix!
            if (window.Visibility != Visibility.Visible)
            {
                window.Visibility = Visibility.Visible;
            }

            // We can't allow the window to be maximized, as there is no de-maximize button!
            if (window.WindowState == WindowState.Maximized)
            {
                window.WindowState = WindowState.Normal;
            }

            window.Topmost = true;
        }
        catch (Exception)
        {
            // Gulp. Avoids "Cannot set visibility while window is closing".
        }
    }

    /// <summary>
    ///     Intent: Ensure that small notification window can be hidden by other windows.
    /// </summary>
    /// <param name="window"></param>
    public static void ShiftWindowIntoBackground(Window window)
    {
        try
        {
            // Prevent the window from grabbing focus away from other windows the first time is created.
            window.ShowActivated = false;

            // Do not use .Show() and .Hide() - not compatible with Citrix!
            if (window.Visibility != Visibility.Collapsed)
            {
                window.Visibility = Visibility.Collapsed;
            }

            // We can't allow the window to be maximized, as there is no de-maximize button!
            if (window.WindowState == WindowState.Maximized)
            {
                window.WindowState = WindowState.Normal;
            }

            window.Topmost = false;
        }
        catch (Exception)
        {
            // Gulp. Avoids "Cannot set visibility while window is closing".
        }
    }
}

Uso

Para usar isso, você precisa criar a janela no seu ViewModel:

private ToastView _toastViewWindow;
private void ShowWindow()
{
    if (_toastViewWindow == null)
    {
        _toastViewWindow = new ToastView();
        _dialogService.Show<ToastView>(this, this, _toastViewWindow, true);
    }
    ShiftWindowOntoScreenHelper.ShiftWindowOntoScreen(_toastViewWindow);
    HideAndShowWindowHelper.ShiftWindowIntoForeground(_toastViewWindow);
}

private void HideWindow()
{
    if (_toastViewWindow != null)
    {
        HideAndShowWindowHelper.ShiftWindowIntoBackground(_toastViewWindow);
    }
}

Links adicionais

Para obter dicas sobre como garantir que uma janela de notificação sempre volte para a tela visível, veja minha resposta: No WPF, como mudar uma janela para a tela se estiver fora da tela? .

Contango
fonte
5
"Código de nível corporativo" e algumas linhas depois catch (Exception) { }. Sim, certo ... E ele usa código que nem é mostrado na resposta como _dialogServiceou ShiftWindowOntoScreenHelper. Além disso pedindo para criar a janela no lado viewmodel (que basicamente quebra todo o padrão MVVM) ...
Kryptos
@Kryptos Este é o código no nível da empresa. Digitei de memória e essa técnica exata é usada em uma grande empresa FTSE100. A vida real é um pouco menos primitiva em comparação com os padrões de design perfeitos que todos nós estamos buscando.
Contango
Eu não gosto do fato de mantermos uma instância da janela no modelo de exibição, como o Kryptos mencionou que quebra todo o ponto do mvvm, talvez isso pudesse ter sido feito em código atrás?
Igor Meszaros
1
@Igor Meszaros concordou. Agora que tenho mais experiência, se tivesse que fazê-lo novamente, adicionaria um Comportamento e o controlaria usando um Func<>vinculado ao ViewModel.
Contango
7

Eu tive um problema semelhante com um aplicativo WPF que é chamado de um aplicativo Access através do objeto Shell.

Minha solução está abaixo - funciona em XP e Win7 x64 com aplicativo compilado para o destino x86.

Prefiro fazer isso do que simular uma tabulação alternativa.

void Window_Loaded(object sender, RoutedEventArgs e)
{
    // make sure the window is normal or maximised
    // this was the core of the problem for me;
    // even though the default was "Normal", starting it via shell minimised it
    this.WindowState = WindowState.Normal;

    // only required for some scenarios
    this.Activate();
}
Seth
fonte
4

Bem, já que esse é um assunto tão quente ... aqui está o que funciona para mim. Eu recebi erros se não fiz dessa maneira, porque Activate () apresentará um erro se você não puder ver a janela.

Xaml:

<Window .... 
        Topmost="True" 
        .... 
        ContentRendered="mainWindow_ContentRendered"> .... </Window>

Código por trás:

private void mainWindow_ContentRendered(object sender, EventArgs e)
{
    this.Topmost = false;
    this.Activate();
    _UsernameTextBox.Focus();
}

Essa era a única maneira de eu mostrar a janela no topo. Em seguida, ative-o para que você possa digitar na caixa sem precisar definir o foco com o mouse. control.Focus () não funcionará, a menos que a janela esteja Active ();

Omzig
fonte
2

Bem, eu descobri uma solução. Estou fazendo a ligação usando um gancho de teclado usado para implementar uma tecla de atalho. A chamada funciona como esperado se eu colocá-la em um BackgroundWorker com uma pausa. É uma ilusão, mas não tenho idéia do por que não estava funcionando originalmente.

void hotkey_execute()
{
    IntPtr handle = new WindowInteropHelper(Application.Current.MainWindow).Handle;
    BackgroundWorker bg = new BackgroundWorker();
    bg.DoWork += new DoWorkEventHandler(delegate
        {
            Thread.Sleep(10);
            SwitchToThisWindow(handle, true);
        });
    bg.RunWorkerAsync();
}
Fator Místico
fonte
Apenas interessado: você tentou o Window.Activate (como sugerido por Morten) e as outras sugestões? Eles parecem menos hacky do que esse kludge admitido.
Simon D.
Este tem sido um bom tempo atrás, mas sim, no momento em que eu tentei que
Fator Místico
Isso não funciona no meu Windows XP. Eu recomendo a resposta de Matthew Xavier.
Lex Li
2

Para mostrar QUALQUER janela aberta no momento, importe essas DLL:

public partial class Form1 : Form
{
    [DllImportAttribute("User32.dll")]
    private static extern int FindWindow(String ClassName, String WindowName);
    [DllImportAttribute("User32.dll")]
    private static extern int SetForegroundWindow(int hWnd);

e no programa Buscamos o aplicativo com o título especificado (escreva o título sem a primeira letra (índice> 0))

  foreach (Process proc in Process.GetProcesses())
                {
                    tx = proc.MainWindowTitle.ToString();
                    if (tx.IndexOf("Title of Your app WITHOUT FIRST LETTER") > 0)
                    {
                        tx = proc.MainWindowTitle;
                        hWnd = proc.Handle.ToInt32(); break;
                    }
                }
                hWnd = FindWindow(null, tx);
                if (hWnd > 0)
                {
                    SetForegroundWindow(hWnd);
                }
rahmud
fonte
"Título do seu aplicativo SEM PRIMEIRA LETRA" Oof, hacky hacky hacky. Por que não usar IndexOfcorretamente?
Lightness Races in Orbit
1

O problema pode ser que o encadeamento que chama seu código do gancho não foi inicializado pelo tempo de execução, portanto, métodos de tempo de execução de chamada não funcionam.

Talvez você possa tentar fazer uma chamada para organizar seu código no thread da interface do usuário para chamar seu código que traz a janela para o primeiro plano.

joshperry
fonte
1

Esses códigos funcionarão bem o tempo todo.

Primeiro defina o manipulador de eventos ativado no XAML:

Activated="Window_Activated"

Adicione abaixo da linha ao seu bloco construtor da Janela Principal:

public MainWindow()
{
    InitializeComponent();
    this.LocationChanged += (sender, e) => this.Window_Activated(sender, e);
}

E dentro do manipulador de eventos ativado, copie estes códigos:

private void Window_Activated(object sender, EventArgs e)
{
    if (Application.Current.Windows.Count > 1)
    {
        foreach (Window win in Application.Current.Windows)
            try
            {
                if (!win.Equals(this))
                {
                    if (!win.IsVisible)
                    {
                        win.ShowDialog();
                    }

                    if (win.WindowState == WindowState.Minimized)
                    {
                        win.WindowState = WindowState.Normal;
                    }

                    win.Activate();
                    win.Topmost = true;
                    win.Topmost = false;
                    win.Focus();
                }
            }
            catch { }
    }
    else
        this.Focus();
}

Essas etapas funcionarão bem e trarão para a frente todas as outras janelas na janela dos pais.

Matriz
fonte
0

Se você está tentando ocultar a janela, por exemplo, minimiza a janela, descobri que usar

    this.Hide();

irá ocultá-lo corretamente, então simplesmente usando

    this.Show();

mostrará a janela como o item mais alto novamente.

Chris
fonte
0

Só queria adicionar outra solução para esta pergunta. Essa implementação funciona no meu cenário, onde o CaliBurn é responsável por exibir a janela principal.

protected override void OnStartup(object sender, StartupEventArgs e)
{
    DisplayRootViewFor<IMainWindowViewModel>();

    Application.MainWindow.Topmost = true;
    Application.MainWindow.Activate();
    Application.MainWindow.Activated += OnMainWindowActivated;
}

private static void OnMainWindowActivated(object sender, EventArgs e)
{
    var window = sender as Window;
    if (window != null)
    {
        window.Activated -= OnMainWindowActivated;
        window.Topmost = false;
        window.Focus();
    }
}
d.moncada
fonte
0

Lembre-se de não colocar o código que mostra essa janela dentro de um manipulador PreviewMouseDoubleClick, pois a janela ativa retornará à janela que manipulou o evento. Basta colocá-lo no manipulador de eventos MouseDoubleClick ou parar de borbulhar definindo e.Handled como True.

No meu caso, eu estava lidando com o PreviewMouseDoubleClick em um Listview e não estava definindo o e.Handled = true; em seguida, ele levantou o evento MouseDoubleClick, que voltou a focalizar a janela original.

Michel P.
fonte
-1

Criei um método de extensão para facilitar a reutilização.

using System.Windows.Forms;
    namespace YourNamespace{
        public static class WindowsFormExtensions {
            public static void PutOnTop(this Form form) {
                form.Show();
                form.Activate();
            }// END PutOnTop()       
        }// END class
    }// END namespace

Chamar no construtor de formulários

namespace YourNamespace{
       public partial class FormName : Form {
       public FormName(){
            this.PutOnTop();
            InitalizeComponents();
        }// END Constructor
    } // END Form            
}// END namespace
Mike
fonte
Olá Mike. Você está respondendo a esta pergunta muito tarde. Você pode explicar em sua resposta por que essa abordagem é diferente (e talvez melhor) das respostas muito boas que já foram publicadas para esta pergunta?
Noel Widmer
Só tarde, eu só precisava fazer isso, e me deparei com isso e queria compartilhar como resolvi o problema, pois outros queriam usá-lo.
1955 Mike
Claro, fui escolhido para revisar sua postagem e queria informá-lo. É sempre bom fornecer uma nova resposta se você acha que é uma boa contribuição para a comunidade.
Noel Widmer
2
Esta pergunta foi especificamente sobre o WPF, mas sua solução é para o WinForms.
Brian Reichle