WPF: 如何设置对话框位置以显示在应用程序的中心？

I think it's easier to use xaml markup

<Window WindowStartupLocation="CenterOwner">

You can try to get a hold of the MainWindow in the Loaded event like this

private void Window_Loaded(object sender, RoutedEventArgs e)
{
Application curApp = Application.Current;
Window mainWindow = curApp.MainWindow;
this.Left = mainWindow.Left + (mainWindow.Width - this.ActualWidth) / 2;
this.Top = mainWindow.Top + (mainWindow.Height - this.ActualHeight) / 2;
}

You must set a parent window to your window (Owner) and then set the WindowStartupLocation property to "CenterParent"

In the XAML belonging to the Dialog:

<Window ... WindowStartupLocation="CenterOwner">

and in C# when you instantiate the Dialog:

MyDlg dlg = new MyDlg();
dlg.Owner = this;


if (dlg.ShowDialog() == true)
{
...

To get a WPF Dialog to position at the centre of a Windows Forms parent form I passed the parent form to the dialog since Application.Current didn't return the Windows Form parent (I assume it only works if the parent app is WPF).

public partial class DialogView : Window
{
private readonly System.Windows.Forms.Form _parent;


public DialogView(System.Windows.Forms.Form parent)
{
InitializeComponent();


_parent = parent;
}


private void Window_Loaded(object sender, RoutedEventArgs e)
{
this.Left = _parent.Left + (_parent.Width - this.ActualWidth) / 2;
this.Top = _parent.Top + (_parent.Height - this.ActualHeight) / 2;
}
}

set the WindowStartupLocation on the WPF Dialog:

<Window WindowStartupLocation="CenterParent">

and the way the Windows Form loads the WPF dialog is like this:

DialogView dlg = new DialogView();
dlg.Owner = this;


if (dlg.ShowDialog() == true)
{
...

I'd like to add to the Fredrik Hedblad response that if the MainWindows has been resized or maximized, the result would be wrong, because mainWindow.Width and mainWindow.Height reflect the value that are set on the XAML.

If you want the actual values, you can use mainWindow.ActualWidth and mainWindow.ActualHeight:

private void Window_Loaded(object sender, RoutedEventArgs e)
{
Application curApp = Application.Current;
Window mainWindow = curApp.MainWindow;
this.Left = mainWindow.Left + (mainWindow.ActualWidth - this.ActualWidth) / 2;
this.Top = mainWindow.Top + (mainWindow.ActualHeight - this.ActualHeight) / 2;
}

Just in code behind.

public partial class CenteredWindow:Window
{
public CenteredWindow()
{
InitializeComponent();


WindowStartupLocation = WindowStartupLocation.CenterOwner;
Owner = Application.Current.MainWindow;
}
}

I found this one the best

frmSample fs = new frmSample();
fs.Owner = this; // <-----
fs.WindowStartupLocation = WindowStartupLocation.CenterOwner;
var result = fs.ShowDialog();

XAML:

    <Window WindowStartupLocation="CenterScreen">

This code works if you don't want to use the WindowStartupLocation property in xaml:

private void CenterWindowOnApplication()
{
System.Windows.Application curApp = System.Windows.Application.Current;
Window mainWindow = curApp.MainWindow;
if (mainWindow.WindowState == WindowState.Maximized)
{
// Get the mainWindow's screen:
var screen = System.Windows.Forms.Screen.FromRectangle(new System.Drawing.Rectangle((int)mainWindow.Left, (int)mainWindow.Top, (int)mainWindow.Width, (int)mainWindow.Height));
double screenWidth = screen.WorkingArea.Width;
double screenHeight = screen.WorkingArea.Height;
double popupwindowWidth = this.Width;
double popupwindowHeight = this.Height;
this.Left = (screenWidth / 2) - (popupwindowWidth / 2);
this.Top = (screenHeight / 2) - (popupwindowHeight / 2);
}
else
{
this.Left = mainWindow.Left + ((mainWindow.ActualWidth - this.ActualWidth) / 2;
this.Top = mainWindow.Top + ((mainWindow.ActualHeight - this.ActualHeight) / 2);
}
}

I am using "screen.WorkingArea" because the task bar makes the mainWindow smaller. If you want to place the window in the middle of the screen, you can use "screen.Bounds" instead.

I think everyone's answers to this question are parts to what the answer should be. I will simply put them together which I believe is the easiest and elegant approach to this problem.

First setup where you want the window to be located. Here it's the owner.

<Window WindowStartupLocation="CenterOwner">

Before opening the window we need to give it the owner and from another post we can access the MainWindow using the static getter for the current application's MainWindow.

        Window window = new Window();
window.Owner = Application.Current.MainWindow;
window.Show();

That's it.

For the child window, set at the XAML

WindowStartupLocation="CenterOwner"

To call your child window as a dialog and center of the parent, call it from the parent window, e.g

private void ConfigButton_OnClick(object sender, RoutedEventArgs e)
{
var window = new ConfigurationWindow
{
Owner = this
};
window.ShowDialog();
}

If you have little control over the windows which you need to show, the following snippet may be useful

    public void ShowDialog(Window window)
{
Dispatcher.BeginInvoke(
new Func<bool?>(() =>
{
window.Owner = Application.Current.MainWindow;
window.WindowStartupLocation = WindowStartupLocation.CenterOwner;
return window.ShowDialog();
}));
}

For the sake of documentation, I'll add here an example of how I achieved something similar. What I needed was a popup that covered the entire parent Window content area (excluding the title bar), but simply centering the dialog and stretching its content didn't work because the dialog was always offset a little bit from the bottom.

Note about user experience: It's not nice not being able to drag/close the parent window when the borderless dialog is showing, so I would reconsider using it. I also decided not to do this after posting this answer, but will leave it up for others to look at.

After some googling and testing, I finally managed to do it like this:

var dialog = new DialogWindow
{
//this = MainWindow
Owner = this
};


dialog.WindowStartupLocation = WindowStartupLocation.Manual;
dialog.WindowStyle = WindowStyle.None;
dialog.ShowInTaskbar = false;
dialog.ResizeMode = ResizeMode.NoResize;
dialog.AllowsTransparency = true;


var ownerContent = (FrameworkElement) Content;
dialog.MaxWidth = ownerContent.ActualWidth;
dialog.Width = ownerContent.ActualWidth;
dialog.MaxHeight = ownerContent.ActualHeight;
dialog.Height = ownerContent.ActualHeight;


var contentPoints = ownerContent.PointToScreen(new Point(0, 0));
dialog.Left = contentPoints.X;
dialog.Top = contentPoints.Y;


dialog.ShowDialog();

The DialogWindow is a Window and its owner is set to the main application Window. The WindowStartupLocation must be set to Manual for manual positioning to work.

Result:

I don't know if there's an easier way to do this, but nothing else seemed to work for me.