public AlertDialogBackend()
 {
     this.buttons = MessageBoxButton.OKCancel;
     this.icon = MessageBoxImage.None;
     this.options = MessageBoxOptions.None;
     this.defaultResult = MessageBoxResult.Cancel;
 }

        private void authorizationButton_Click(object sender, RoutedEventArgs e)
        {
            string login = loginComboBox.SelectedValue.ToString();
            string password = passwordTextBox.Password;          

            if (AuthorizationDefend.EntranceToSystem(login, password) == false)
            {
                MessageBoxResult result = new MessageBoxResult();
                result=MessageBox.Show("Ошибка авторизации! Неверный ввод пароля.", "Ошибка авторизации", MessageBoxButton.OK, MessageBoxImage.Error);

                if (result == MessageBoxResult.OK)
                {
                    loginComboBox.SelectedIndex = 0;
                    passwordTextBox.Clear();
                }
            }
            else
            {
                mainMenuWindow mainMenuWindow = new mainMenuWindow();

                if (loginComboBox.SelectedIndex == 0)
                {
                    mainMenuWindow.Title = "Администратор: Главное меню";
                }
                else
                {
                    mainMenuWindow.Title = "Пользователь: Главное меню";
                }
                
                mainMenuWindow.Show();
                this.Close();
            }
            
        }

 public static MessageBoxResult Show(string messageBoxText, string caption, MessageBoxButton button, MessageBoxImage icon, MessageBoxResult defaultResult)
 {
     if (_provider != null)
         return _provider.Show(messageBoxText, caption, button, icon, defaultResult);
     else
         return MessageBox.Show(messageBoxText, caption, button, icon, defaultResult);
 }

    /// <summary>
    /// Called when the dialog completes.
    /// </summary>
    /// <param name="result">The result of the message box.</param>
    public void DialogComplete(MessageBoxResult result)
    {
      if (CompleteCallback == null)
        return;

      CompleteCallback(result);
    }

 public static void ShowAsync(string text, MessageBoxButton button = MessageBoxButton.OK,
     MessageBoxImage image = MessageBoxImage.Information, MessageBoxResult defaultButton = MessageBoxResult.OK)
 {
     new Thread(
         new ThreadStart(delegate { MessageBox.Show(text, Resources.AppName, button, image, defaultButton); }))
         .Start();
 }

        protected void CloseWithResult(MessageBoxResult? result) {
            if (result.HasValue) {
                MessageBoxResult = result.Value;

                try {
                    // sets the Window.DialogResult as well
                    // ReSharper disable once SwitchStatementMissingSomeCases
                    switch (result.Value) {
                        case MessageBoxResult.OK:
                        case MessageBoxResult.Yes:
                            DialogResult = true;
                            break;
                        case MessageBoxResult.Cancel:
                        case MessageBoxResult.No:
                            DialogResult = false;
                            break;
                        default:
                            DialogResult = null;
                            break;
                    }
                } catch (InvalidOperationException) {
                    // TODO: Maybe there is a better way?
                }
            }

            Close();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ModernDialog"/> class.
        /// </summary>
        public ModernDialog()
        {
            this.DefaultStyleKey = typeof(ModernDialog);
            this.WindowStartupLocation = WindowStartupLocation.CenterOwner;

            this.closeCommand = new RelayCommand(o => {
                var result = o as MessageBoxResult?;
                if (result.HasValue) {
                    this.messageBoxResult = result.Value;

                    // sets the Window.DialogResult as well
                    if (result.Value == MessageBoxResult.OK || result.Value == MessageBoxResult.Yes) {
                        this.DialogResult = true;
                    }
                    else if (result.Value == MessageBoxResult.Cancel || result.Value == MessageBoxResult.No){
                        this.DialogResult = false;
                    }
                    else{
                        this.DialogResult = null;
                    }
                }
                Close();
            });

            this.Buttons = new Button[] { this.CloseButton };

            // set the default owner to the app main window (if possible)
            if (Application.Current != null && Application.Current.MainWindow != this) {
                this.Owner = Application.Current.MainWindow;
            }
        }

        public static async Task<MessageBoxResult> ShowAsyncModified(string msg, string cap, string optionOne, string optionTwo)
        {
            MessageBoxResult i = new MessageBoxResult();

            // Create the message dialog and set its content and title
            var messageDialog = new MessageDialog("New updates have been found for this program. Would you like to install the new updates?", "Updates available");

            // Add commands and set their callbacks
            messageDialog.Commands.Add(new UICommand(optionOne, (command) =>
            {
                i = MessageBoxResult.Working;
            }));

            messageDialog.Commands.Add(new UICommand(optionTwo, (command) =>
            {
                i = MessageBoxResult.NonWorking;
            }));

            messageDialog.Commands.Add(new UICommand("Cancel", (command) =>
            {
                i = MessageBoxResult.Cancel;
            }));

            // Set the command that will be invoked by default
            messageDialog.DefaultCommandIndex = (uint)MessageBoxResult.Cancel;

            // Show the message dialog
            await messageDialog.ShowAsync();

            return i;
        }

        public static MessageBoxResult Show(
            Action<Window> setOwner,
            string messageBoxText, 
            string caption, 
            MessageBoxButton button, 
            MessageBoxImage icon, 
            MessageBoxResult defaultResult, 
            MessageBoxOptions options)
        {
            if ((options & MessageBoxOptions.DefaultDesktopOnly) == MessageBoxOptions.DefaultDesktopOnly)
            {
                throw new NotImplementedException();
            }

            if ((options & MessageBoxOptions.ServiceNotification) == MessageBoxOptions.ServiceNotification)
            {
                throw new NotImplementedException();
            }

            _messageBoxWindow = new WpfMessageBoxWindow();

            setOwner(_messageBoxWindow);

            PlayMessageBeep(icon);

            _messageBoxWindow._viewModel = new MessageBoxViewModel(_messageBoxWindow, caption, messageBoxText, button, icon, defaultResult, options);
            _messageBoxWindow.DataContext = _messageBoxWindow._viewModel;
            _messageBoxWindow.ShowDialog();
            return _messageBoxWindow._viewModel.Result;
        }

        public static MessageBoxResult Show(
            Action<Window> setOwner,
            CultureInfo culture,
            string messageBoxText,
            string caption,
            WPFMessageBoxButton button,
            MessageBoxImage icon,
            MessageBoxResult defaultResult,
            MessageBoxOptions options)
        {
            if ((options & MessageBoxOptions.DefaultDesktopOnly) == MessageBoxOptions.DefaultDesktopOnly)
            {
                throw new NotImplementedException();
            }

            if ((options & MessageBoxOptions.ServiceNotification) == MessageBoxOptions.ServiceNotification)
            {
                throw new NotImplementedException();
            }
            //LocalizeDictionary.Instance.Culture = CultureInfo.GetCultureInfo("de");
            _messageBoxWindow = new WPFMessageBoxWindow();

            setOwner(_messageBoxWindow);

            PlayMessageBeep(icon);
            //FrameworkElement.LanguageProperty.OverrideMetadata(typeof(FrameworkElement), new FrameworkPropertyMetadata(
            //            XmlLanguage.GetLanguage(culture.IetfLanguageTag)));
            _messageBoxWindow._viewModel = new MessageBoxViewModel(_messageBoxWindow, culture, caption, messageBoxText, button, icon, defaultResult, options);
            _messageBoxWindow.DataContext = _messageBoxWindow._viewModel;
            _messageBoxWindow.ShowDialog();
            return _messageBoxWindow._viewModel.Result;
        }

 public MessageBoxButtonViewModel(string text, MessageBoxResult result, Action<MessageBoxResult> returnAction, bool hasInitFocus = false)
 {
     m_text = text;
       m_result = result;
       m_hasInitFocus = hasInitFocus;
       m_command = new GenericManualCommand<MessageBoxResult>(returnAction);
 }

      private static OLEMSGDEFBUTTON ToOleDefault(MessageBoxResult defaultResult, MessageBoxButton button)
      {
         switch (button)
         {
            case MessageBoxButton.OK:
               return OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST;

            case MessageBoxButton.OKCancel:
               if (defaultResult == MessageBoxResult.Cancel)
                  return OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_SECOND;

               return OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST;

            case MessageBoxButton.YesNoCancel:
               if (defaultResult == MessageBoxResult.No)
                  return OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_SECOND;
               if (defaultResult == MessageBoxResult.Cancel)
                  return OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_THIRD;

               return OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST;

            case MessageBoxButton.YesNo:
               if (defaultResult == MessageBoxResult.No)
                  return OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_SECOND;

               return OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST;
         }

         return OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST;
      }

        private static MessageBoxResult ShowCore(
            string messageBoxText,
            string caption,
            MessageBoxButton button,
            MessageDialogImage icon,
            MessageBoxResult defaultResult)
        {
            if (!IsValidMessageBoxButton(button))
            {
                throw new InvalidEnumArgumentException("button", (int)button, typeof(MessageBoxButton));
            }

            if (!IsValidMessageDialogImage(icon))
            {
                throw new InvalidEnumArgumentException("icon", (int)icon, typeof(MessageBoxImage));
            }

            if (!IsValidMessageBoxResult(defaultResult))
            {
                throw new InvalidEnumArgumentException("defaultResult", (int)defaultResult, typeof(MessageBoxResult));
            }

            var dialog = new Dialog(messageBoxText, caption, button, icon, defaultResult);
            var flag = dialog.ShowDialog();
            return flag == true ? MessageBoxResult.No : MessageBoxResult.None;
        }

        /// <summary>
        /// Displays the specified message box as a modal dialog.
        /// </summary>
        /// <param name="mb">The message box to display.</param>
        /// <param name="text">The text to display.</param>
        /// <param name="caption">The caption to display.</param>
        /// <param name="button">A <see cref="MessageBoxButton"/> value that specifies the set of buttons to display.</param>
        /// <param name="image">A <see cref="MessageBoxImage"/> value that specifies the image to display.</param>
        /// <param name="defaultResult">A <see cref="MessageBoxResult"/> value that specifies the message box's default option.</param>
        public static void Show(MessageBoxModal mb, String text, String caption, MessageBoxButton button, MessageBoxImage image, MessageBoxResult defaultResult)
        {
            Contract.Require(mb, "mb");
            
            mb.Prepare(text, caption, button, image, defaultResult);

            Modal.ShowDialog(mb);
        }

 public MessageBoxResult Prompt(string message,
     string title = DefaultTitle,
     MessageBoxButton button = DefaultButton,
     MessageBoxImage icon = MessageBoxImage.Question,
     MessageBoxResult defaultResult = DefaultResult)
 {
     return this.uiShell.Prompt(message, title, button, icon, defaultResult);
 }

 /// <summary>
 /// Prepares the message box to be displayed.
 /// </summary>
 /// <param name="text">The message box's text.</param>
 /// <param name="caption">The message box's caption.</param>
 /// <param name="button">A <see cref="MessageBoxButton"/> value that specifies the set of buttons to display.</param>
 /// <param name="image">A <see cref="MessageBoxImage"/> value that specifies the image to display.</param>
 /// <param name="defaultResult">A <see cref="MessageBoxResult"/> value that specifies the message box's default option.</param>
 internal void Prepare(String text, String caption, MessageBoxButton button, MessageBoxImage image, MessageBoxResult defaultResult)
 {
     var vm = screen.View.GetViewModel<MessageBoxViewModel>();
     if (vm != null)
     {
         vm.Prepare(text, caption, button, image, defaultResult);
     }
 }

 public MessageBoxResult Show(string messageBoxText, string caption, MessageBoxButton button, MessageBoxResult defaultResult) {
     MessageBoxTest = messageBoxText;
     Caption = caption;
     Button = button;
     DefaultResult = defaultResult;
     ShowCount++;
     return Result;
 }

 private static bool IsValidMessageBoxResult(MessageBoxResult value)
 {
     return value == MessageBoxResult.Cancel
         || value == MessageBoxResult.No
         || value == MessageBoxResult.None
         || value == MessageBoxResult.OK
         || value == MessageBoxResult.Yes;
 }

 public bool? Show(string message,
     string title = DefaultTitle,
     MessageBoxButton button = DefaultButton,
     MessageBoxImage icon = DefaultIcon,
     MessageBoxResult defaultResult = DefaultResult)
 {
     return this.uiShell.ShowMessageBox(message, title, button, icon, defaultResult);
 }

 //Button Exit Click
 private void DatabaseSettingButtonExitClick(object sender, System.Windows.RoutedEventArgs e)
 {
     MessageBoxResult messBoxResult = new MessageBoxResult();
     messBoxResult = Microsoft.Windows.Controls.MessageBox.Show(Variables.ERROR_MESSAGES[1, 1], Variables.ERROR_MESSAGES[0, 0], MessageBoxButton.YesNo, MessageBoxImage.Question);
     if (messBoxResult.Equals(MessageBoxResult.Yes))
     {
         Application.Current.Shutdown();
     }
 }