Как скрыть кнопку закрытия в окне WPF?

Question

Как скрыть кнопку закрытия в окне WPF?

Я пишу модальный диалог в WPF. Как установить окно WPF, чтобы не иметь кнопки закрытия? Я все равно хотел бы, чтобы его WindowState имел обычную строку заголовка.

Я нашел ResizeMode, WindowState и WindowStyle, но ни одно из этих свойств не позволяет мне скрыть кнопку закрытия, но показать строку заголовка, как в модальных диалогах.

185

button dialog wpf xaml

автор: daniele3004

19 ответов

автор: Joe White · Accepted Answer · 2009-06-06 04:15:13

WPF не имеет встроенного свойства, чтобы скрыть кнопку закрытия строки заголовка, но вы можете сделать это с помощью нескольких строк P/Invoke.

во-первых, добавьте эти объявления в свой класс окна:

private const int GWL_STYLE = -16;
private const int WS_SYSMENU = 0x80000;
[DllImport("user32.dll", SetLastError = true)]
private static extern int GetWindowLong(IntPtr hWnd, int nIndex);
[DllImport("user32.dll")]
private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

затем поместите этот код в событие Loaded окна:

var hwnd = new WindowInteropHelper(this).Handle;
SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_SYSMENU);

и вот вы идете: больше нет кнопки закрытия. У вас также не будет значка окна в левой части строки заголовка, что означает отсутствие системного меню, даже если вы щелкните правой кнопкой мыши строку заголовка-они все идут вместе.

обратите внимание, что Alt+F4 все равно закроет окно. Если вы не хотите, чтобы окно закрывалось до завершения фонового потока, вы также можете переопределить OnClosing и установить Cancel в true, как предложил Гейб.

автор: SpudCZ · Accepted Answer · 2014-06-03 12:39:10

Я только что получил аналогичную проблему, и решение Джо Уайта кажется мне простым и чистым. Я повторно использовал его и определил его как прикрепленное свойство Window

public class WindowBehavior
{
    private static readonly Type OwnerType = typeof (WindowBehavior);

    #region HideCloseButton (attached property)

    public static readonly DependencyProperty HideCloseButtonProperty =
        DependencyProperty.RegisterAttached(
            "HideCloseButton",
            typeof (bool),
            OwnerType,
            new FrameworkPropertyMetadata(false, new PropertyChangedCallback(HideCloseButtonChangedCallback)));

    [AttachedPropertyBrowsableForType(typeof(Window))]
    public static bool GetHideCloseButton(Window obj) {
        return (bool)obj.GetValue(HideCloseButtonProperty);
    }

    [AttachedPropertyBrowsableForType(typeof(Window))]
    public static void SetHideCloseButton(Window obj, bool value) {
        obj.SetValue(HideCloseButtonProperty, value);
    }

    private static void HideCloseButtonChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var window = d as Window;
        if (window == null) return;

        var hideCloseButton = (bool)e.NewValue;
        if (hideCloseButton && !GetIsHiddenCloseButton(window)) {
            if (!window.IsLoaded) {
                window.Loaded += HideWhenLoadedDelegate;
            }
            else {
                HideCloseButton(window);
            }
            SetIsHiddenCloseButton(window, true);
        }
        else if (!hideCloseButton && GetIsHiddenCloseButton(window)) {
            if (!window.IsLoaded) {
                window.Loaded -= ShowWhenLoadedDelegate;
            }
            else {
                ShowCloseButton(window);
            }
            SetIsHiddenCloseButton(window, false);
        }
    }

    #region Win32 imports

    private const int GWL_STYLE = -16;
    private const int WS_SYSMENU = 0x80000;
    [DllImport("user32.dll", SetLastError = true)]
    private static extern int GetWindowLong(IntPtr hWnd, int nIndex);
    [DllImport("user32.dll")]
    private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

    #endregion

    private static readonly RoutedEventHandler HideWhenLoadedDelegate = (sender, args) => {
        if (sender is Window == false) return;
        var w = (Window)sender;
        HideCloseButton(w);
        w.Loaded -= HideWhenLoadedDelegate;
    };

    private static readonly RoutedEventHandler ShowWhenLoadedDelegate = (sender, args) => {
        if (sender is Window == false) return;
        var w = (Window)sender;
        ShowCloseButton(w);
        w.Loaded -= ShowWhenLoadedDelegate;
    };

    private static void HideCloseButton(Window w) {
        var hwnd = new WindowInteropHelper(w).Handle;
        SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_SYSMENU);
    }

    private static void ShowCloseButton(Window w) {
        var hwnd = new WindowInteropHelper(w).Handle;
        SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) | WS_SYSMENU);
    }

    #endregion

    #region IsHiddenCloseButton (readonly attached property)

    private static readonly DependencyPropertyKey IsHiddenCloseButtonKey =
        DependencyProperty.RegisterAttachedReadOnly(
            "IsHiddenCloseButton",
            typeof (bool),
            OwnerType,
            new FrameworkPropertyMetadata(false));

    public static readonly DependencyProperty IsHiddenCloseButtonProperty =
        IsHiddenCloseButtonKey.DependencyProperty;

    [AttachedPropertyBrowsableForType(typeof(Window))]
    public static bool GetIsHiddenCloseButton(Window obj) {
        return (bool)obj.GetValue(IsHiddenCloseButtonProperty);
    }

    private static void SetIsHiddenCloseButton(Window obj, bool value) {
        obj.SetValue(IsHiddenCloseButtonKey, value);
    }

    #endregion

}

затем в XAML вы просто устанавливаете его следующим образом:

<Window 
    x:Class="WafClient.Presentation.Views.SampleWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:u="clr-namespace:WafClient.Presentation.Behaviors"
    ResizeMode="NoResize"
    u:WindowBehavior.HideCloseButton="True">
    ...
</Window>

автор: Sriwantha Attanayake · Accepted Answer · 2012-08-23 11:25:50

Set WindowStyle свойство None, которое скроет поле управления вместе со строкой заголовка. Не нужно керналь звонки.

автор: flurbius · Accepted Answer · 2014-07-28 09:19:54

Это не избавится от кнопки закрытия, но это остановит кого-то, закрывающего окно.

поместите это в свой код позади файла:

protected override void OnClosing(CancelEventArgs e)
{
   base.OnClosing(e);
   e.Cancel = true;
}

автор: Viachaslau Tysianchuk · Accepted Answer · 2009-10-26 10:33:56

чтобы отключить кнопку закрытия, вы должны добавить следующий код в свой класс окна (код был взят из здесь, отредактировано и немного переформатировано):

protected override void OnSourceInitialized(EventArgs e)
{
    base.OnSourceInitialized(e);

    HwndSource hwndSource = PresentationSource.FromVisual(this) as HwndSource;

    if (hwndSource != null)
    {
        hwndSource.AddHook(HwndSourceHook);
    }

}

private bool allowClosing = false;

[DllImport("user32.dll")]
private static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);
[DllImport("user32.dll")]
private static extern bool EnableMenuItem(IntPtr hMenu, uint uIDEnableItem, uint uEnable);

private const uint MF_BYCOMMAND = 0x00000000;
private const uint MF_GRAYED = 0x00000001;

private const uint SC_CLOSE = 0xF060;

private const int WM_SHOWWINDOW = 0x00000018;
private const int WM_CLOSE = 0x10;

private IntPtr HwndSourceHook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
    switch (msg)
    {
        case WM_SHOWWINDOW:
            {
                IntPtr hMenu = GetSystemMenu(hwnd, false);
                if (hMenu != IntPtr.Zero)
                {
                    EnableMenuItem(hMenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
                }
            }
            break;
        case WM_CLOSE:
            if (!allowClosing)
            {
                handled = true;
            }
            break;
    }
    return IntPtr.Zero;
}

этот код также отключает пункт Закрыть в системном меню и запрещает закрытие диалога с помощью Alt+F4.

вы, вероятно, захотите закрыть окно программно. Звоню Close() не будет работать. Сделайте что-нибудь вроде этого:

allowClosing = true;
Close();

автор: stijn · Accepted Answer · 2013-06-22 10:04:11

Я пытался ответить Viachaslau, так как мне нравится идея не удалять кнопку, но отключить ее, но по какой-то причине она не всегда работала: кнопка закрытия все еще была включена, но никаких ошибок вообще.

это, с другой стороны, всегда работало (проверка ошибок опущена):

[DllImport( "user32.dll" )]
private static extern IntPtr GetSystemMenu( IntPtr hWnd, bool bRevert );
[DllImport( "user32.dll" )]
private static extern bool EnableMenuItem( IntPtr hMenu, uint uIDEnableItem, uint uEnable );

private const uint MF_BYCOMMAND = 0x00000000;
private const uint MF_GRAYED = 0x00000001;
private const uint SC_CLOSE = 0xF060;
private const int WM_SHOWWINDOW = 0x00000018;

protected override void OnSourceInitialized( EventArgs e )
{
  base.OnSourceInitialized( e );
  var hWnd = new WindowInteropHelper( this );
  var sysMenu = GetSystemMenu( hWnd.Handle, false );
  EnableMenuItem( sysMenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED );
}

автор: tom.maruska · Accepted Answer · 2017-05-23 12:10:41

Я просто добавляю свою реализацию ответ Джо Уайта использование поведения интерактивности (вам нужно ссылаться на систему.Окна.Интерактивность.)

код:

public class HideCloseButtonOnWindow : Behavior<Window>
{
    #region bunch of native methods

    private const int GWL_STYLE = -16;
    private const int WS_SYSMENU = 0x80000;

    [DllImport("user32.dll", SetLastError = true)]
    private static extern int GetWindowLong(IntPtr hWnd, int nIndex);

    [DllImport("user32.dll")]
    private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

    #endregion

    protected override void OnAttached()
    {
        base.OnAttached();
        AssociatedObject.Loaded += OnLoaded;
    }

    protected override void OnDetaching()
    {
        AssociatedObject.Loaded -= OnLoaded;
        base.OnDetaching();
    }

    private void OnLoaded(object sender, RoutedEventArgs e)
    {
        var hwnd = new WindowInteropHelper(AssociatedObject).Handle;
        SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_SYSMENU);
    }
}

использование:

<Window x:Class="WpfApplication2.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
        xmlns:w="clr-namespace:WpfApplication2">

    <i:Interaction.Behaviors>
        <w:HideCloseButtonOnWindow />
    </i:Interaction.Behaviors>

</Window>

автор: daniele3004 · Accepted Answer · 2014-04-29 13:23:33

свойство для установки равно => WindowStyle="None"

<Window x:Class="mdaframework.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            Title="Start" Height="350" Width="525" ResizeMode="NoResize"  WindowStartupLocation="CenterScreen" WindowStyle="None">

автор: BSalita · Accepted Answer · 2010-08-06 08:38:24

пользователь "закрыть" окно, но на самом деле просто скрывают это.

в событии OnClosing окна, скрыть окно, если уже видно:

    If Me.Visibility = Windows.Visibility.Visible Then
        Me.Visibility = Windows.Visibility.Hidden
        e.Cancel = True
    End If

каждый раз, когда фоновый поток должен быть выполнен, повторно показать фоновое окно пользовательского интерфейса:

    w.Visibility = Windows.Visibility.Visible
    w.Show()

при завершении выполнения программы, убедитесь, что все окна могут быть закрыты:

Private Sub CloseAll()
    If w IsNot Nothing Then
        w.Visibility = Windows.Visibility.Collapsed ' Tell OnClosing to really close
        w.Close()
    End If
End Sub

автор: Muad'Dib · Accepted Answer · 2009-04-13 14:55:50

Итак, в значительной степени здесь ваша проблема. Кнопка закрыть в правом верхнем углу оконной рамы не является частью окна WPF, но принадлежит той части оконной рамы, которая управляется вашей ОС. Это означает, что для этого вам придется использовать Win32 interop.

альтернативно, вы можете использовать noframe и либо предоставить свой собственный "кадр", либо вообще не иметь кадра.

автор: daniele3004 · Accepted Answer · 2018-02-27 13:18:35

следующее касается отключения кнопок закрытия и максимизации/минимизации, это делает не фактически удалите кнопки (но он удаляет пункты меню!). Кнопки в строке заголовка отображаются в отключенном / сером состоянии. (Я не совсем готов взять на себя всю функциональность самостоятельно ^^)

это немного отличается от решения Virgoss в том, что он удаляет пункты меню (и конечный разделитель, если необходимо), а не просто отключает их. Он отличается из решения Joe Whites, поскольку оно не отключает все системное меню, и поэтому, в моем случае, я могу держать вокруг кнопки и значка минимизации.

код следования также поддерживает отключение кнопок максимизации / минимизации, так как, в отличие от кнопки закрытия, удаление записей из меню не заставляет систему отображать кнопки "отключено", даже если удаление записей меню тут отключить функции кнопок.

это работает для меня. YMMV.

    using System;
    using System.Collections.Generic;
    using System.Text;

    using System.Runtime.InteropServices;
    using Window = System.Windows.Window;
    using WindowInteropHelper = System.Windows.Interop.WindowInteropHelper;
    using Win32Exception = System.ComponentModel.Win32Exception;

    namespace Channelmatter.Guppy
    {

        public class WindowUtil
        {
            const int MF_BYCOMMAND = 0x0000;
            const int MF_BYPOSITION = 0x0400;

            const uint MFT_SEPARATOR = 0x0800;

            const uint MIIM_FTYPE = 0x0100;

            [DllImport("user32", SetLastError=true)]
            private static extern uint RemoveMenu(IntPtr hMenu, uint nPosition, uint wFlags);

            [DllImport("user32", SetLastError=true)]
            private static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);

            [DllImport("user32", SetLastError=true)]
            private static extern int GetMenuItemCount(IntPtr hWnd);

            [StructLayout(LayoutKind.Sequential)]
            public struct MenuItemInfo {
                public uint   cbSize;
                public uint   fMask;
                public uint   fType;
                public uint   fState;
                public uint   wID;
                public IntPtr hSubMenu;
                public IntPtr hbmpChecked;
                public IntPtr hbmpUnchecked;
                public IntPtr dwItemData; // ULONG_PTR
                public IntPtr dwTypeData;
                public uint   cch;
                public IntPtr hbmpItem;
            };

            [DllImport("user32", SetLastError=true)]
            private static extern int GetMenuItemInfo(
                IntPtr hMenu, uint uItem,
                bool fByPosition, ref MenuItemInfo itemInfo);

            public enum MenuCommand : uint
            {
                SC_CLOSE = 0xF060,
                SC_MAXIMIZE = 0xF030,
            }

            public static void WithSystemMenu (Window win, Action<IntPtr> action) {
                var interop = new WindowInteropHelper(win);
                IntPtr hMenu = GetSystemMenu(interop.Handle, false);
                if (hMenu == IntPtr.Zero) {
                    throw new Win32Exception(Marshal.GetLastWin32Error(),
                        "Failed to get system menu");
                } else {
                    action(hMenu);
                }
            }

            // Removes the menu item for the specific command.
            // This will disable and gray the Close button and disable the
            // functionality behind the Maximize/Minimuze buttons, but it won't
            // gray out the Maximize/Minimize buttons. It will also not stop
            // the default Alt+F4 behavior.
            public static void RemoveMenuItem (Window win, MenuCommand command) {
                WithSystemMenu(win, (hMenu) => {
                    if (RemoveMenu(hMenu, (uint)command, MF_BYCOMMAND) == 0) {
                        throw new Win32Exception(Marshal.GetLastWin32Error(),
                            "Failed to remove menu item");
                    }
                });
            }

            public static bool RemoveTrailingSeparator (Window win) {
                bool result = false; // Func<...> not in .NET3 :-/
                WithSystemMenu(win, (hMenu) => {
                    result = RemoveTrailingSeparator(hMenu);
                });
                return result;
            }

            // Removes the final trailing separator of a menu if it exists.
            // Returns true if a separator is removed.
            public static bool RemoveTrailingSeparator (IntPtr hMenu) {
                int menuItemCount = GetMenuItemCount(hMenu);
                if (menuItemCount < 0) {
                    throw new Win32Exception(Marshal.GetLastWin32Error(),
                        "Failed to get menu item count");
                }
                if (menuItemCount == 0) {
                    return false;
                } else {
                    uint index = (uint)(menuItemCount - 1);
                    MenuItemInfo itemInfo = new MenuItemInfo {
                        cbSize = (uint)Marshal.SizeOf(typeof(MenuItemInfo)),
                        fMask = MIIM_FTYPE,
                    };

                    if (GetMenuItemInfo(hMenu, index, true, ref itemInfo) == 0) {
                        throw new Win32Exception(Marshal.GetLastWin32Error(),
                            "Failed to get menu item info");
                    }

                    if (itemInfo.fType == MFT_SEPARATOR) {
                        if (RemoveMenu(hMenu, index, MF_BYPOSITION) == 0) {
                            throw new Win32Exception(Marshal.GetLastWin32Error(),
                                "Failed to remove menu item");
                        }
                        return true;
                    } else {
                        return false;
                    }
                }
            }

            private const int GWL_STYLE = -16;

            [Flags]
            public enum WindowStyle : int
            {
                WS_MINIMIZEBOX = 0x00020000,
                WS_MAXIMIZEBOX = 0x00010000,
            }

            // Don't use this version for dealing with pointers
            [DllImport("user32", SetLastError=true)]
            private static extern int SetWindowLong (IntPtr hWnd, int nIndex, int dwNewLong);

            // Don't use this version for dealing with pointers
            [DllImport("user32", SetLastError=true)]
            private static extern int GetWindowLong (IntPtr hWnd, int nIndex);

            public static int AlterWindowStyle (Window win,
                WindowStyle orFlags, WindowStyle andNotFlags) 
            {
                var interop = new WindowInteropHelper(win);

                int prevStyle = GetWindowLong(interop.Handle, GWL_STYLE);
                if (prevStyle == 0) {
                    throw new Win32Exception(Marshal.GetLastWin32Error(),
                        "Failed to get window style");
                }

                int newStyle = (prevStyle | (int)orFlags) & ~((int)andNotFlags);
                if (SetWindowLong(interop.Handle, GWL_STYLE, newStyle) == 0) {
                    throw new Win32Exception(Marshal.GetLastWin32Error(),
                        "Failed to set window style");
                }
                return prevStyle;
            }

            public static int DisableMaximizeButton (Window win) {
                return AlterWindowStyle(win, 0, WindowStyle.WS_MAXIMIZEBOX);
            }
        }
    }

использование: это должно быть сделано после инициализации источника. Хорошим местом является использование события SourceInitialized окна:

Window win = ...; /* the Window :-) */
WindowUtil.DisableMaximizeButton(win);
WindowUtil.RemoveMenuItem(win, WindowUtil.MenuCommand.SC_MAXIMIZE);
WindowUtil.RemoveMenuItem(win, WindowUtil.MenuCommand.SC_CLOSE);
while (WindowUtil.RemoveTrailingSeparator(win)) 
{
   //do it here
}

чтобы отключить функциональность Alt+F4, простой способ - просто подключить событие отмены и использовать флаг, когда вы действительно хотите закрыть окно.

автор: TStamper · Accepted Answer · 2010-01-29 13:23:13

код XAML

<Button Command="Open" Content="_Open">
    <Button.Style>
        <Style TargetType="Button">
            <Style.Triggers>
                <Trigger Property="IsEnabled" Value="False">
                    <Setter Property="Visibility" Value="Collapsed" />
                </Trigger>
            </Style.Triggers>
        </Style>
     </Button.Style>
</Button>

должно работать

редактировать- на этот нить показывает, как это можно сделать, но я не думаю, что окно имеет свойство, чтобы получить то, что вы хотите, не теряя нормального заголовка.

Изменить 2 Это нить показывает, как это сделать, но вы должны применить свой собственный стиль к системному меню, и он показывает, как вы можете это сделать.

автор: Pavan R Bhupalam · Accepted Answer · 2013-07-30 10:25:11

Гото окне "Свойства" установите для параметра

window style = none;

u не получит кнопки закрытия...

автор: Dennis R · Accepted Answer · 2016-08-06 15:57:32

попробуйте добавить событие закрытия окна. Добавьте этот код в обработчик событий.

e.Cancel = true;

это предотвратит закрытие окна. Это имеет тот же эффект, что и скрытие кнопки закрытия.

автор: vapcguy · Accepted Answer · 2017-03-21 18:24:30

используйте это, измененное из https://stephenhaunts.com/2014/09/25/remove-the-close-button-from-a-wpf-window:

using System;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;

namespace Whatever
{
    public partial class MainMenu : Window
    {
        private const int GWL_STYLE = -16;
        private const int WS_SYSMENU = 0x00080000;

        [DllImport("user32.dll", SetLastError = true)]
        private static extern int GetWindowLongPtr(IntPtr hWnd, int nIndex);

        [DllImport("user32.dll")]
        private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

        public MainMenu()
        {
             InitializeComponent();
             this.Loaded += new RoutedEventHandler(Window_Loaded);
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            var hwnd = new WindowInteropHelper(this).Handle;
            SetWindowLongPtr(hwnd, GWL_STYLE, GetWindowLongPtr(hwnd, GWL_STYLE) & ~WS_SYSMENU);
        }  

    }
}

автор: Joe Horr · Accepted Answer · 2018-01-16 16:05:10

после долгих поисков ответа на этот вопрос, я разработал это простое решение, которое я поделюсь здесь в надежде, что это поможет другим.

Я WindowStyle=0x10000000.

установка WS_VISIBLE (0x10000000) и WS_OVERLAPPED (0x0) значения для стиля окна. "Перекрывается" - это необходимое значение для отображения строки заголовка и границы окна. Путем удаления WS_MINIMIZEBOX (0x20000), WS_MAXIMIZEBOX (0x10000) и WS_SYSMENU (0x80000) значения из моего значения стиля были удалены все кнопки из строки заголовка, включая кнопку закрытия.

автор: Holf · Accepted Answer · 2013-09-12 17:05:11

как указано в других ответах, вы можете использовать WindowStyle="None" чтобы полностью удалить строку заголовка.

и, как указано в комментариях к этим другим ответам, это предотвращает перетаскивание окна, поэтому его трудно переместить из исходного положения.

однако вы можете преодолеть это, добавив одну строку кода в конструктор в коде окна за файлом:

MouseDown += delegate { DragMove(); };

или, если вы предпочитаете лямбда-синтаксис:

MouseDown += (sender, args) => DragMove();

Это делает все окно задрапировано. Все интерактивные элементы управления, присутствующие в окне, такие как кнопки, будут по-прежнему работать как обычно и не будут выступать в качестве маркеров перетаскивания для окна.

автор: Vishal Nayan · Accepted Answer · 2012-11-04 06:30:24

использовать WindowStyle="SingleBorderWindow", это скроет кнопку max и min из окна WPF.

автор: Filipe Piletti Plucenio · Accepted Answer · 2017-04-26 23:41:38

Если нужно только запретить пользователю закрывать окно, это простое решение.

код XAML: IsCloseButtonEnabled="False"