Question

Currenlty, I’m using as Below.

In xaml,

<Button Content="X" Width="33" Height="16" Padding="1,-2,1,0"  
 Command="{Binding ElementName=UserControlName, Path=DataContext.DenyCommand}"
   <Button.CommandParameter>
     <wpfext:UICommandParameter UICommandCallerCallback="{Binding ElementName=UserControlName, Path=UIDenyCallBackCommand}"/>
   </Button.CommandParameter>
</Button>

In xaml.cs,

 public UICommandCallerCallback UIDenyCallBackCommand
        {
            get;
            private set;
        }
public UserControlName()
        {

            this.UIDenyCallBackCommand = this.UIAccessDenyCallBack;
            this.InitializeComponent();

        }

 public void UIAccessDenyCallBack(object commandParameter, object callbackData)
        {
            ShowADenyMsgBox();
        }

private void ShowDenyMsgBox()
{
             RightsDenied win = new RightsDenied(); //xaml window
            win.Owner = GetImmediateWindow();
            win.WindowStartupLocation = WindowStartupLocation.CenterScreen;
            win.ShowDialog();
}

In ViewModel.cs,

internal ViewModel()
        {
         this.DenyCommand= new DenyCommand(this.AccessDeny);
        }
public void AccessDeny(ICommandState commandState)
        {
            commandState.InvokeCallerCallback("AccessDenied");
        }

public CommandCallback DenyCommand
        {
            get;
            private set;
        }

UICommandCallerCallback is declared as below.

public delegate void UICommandCallerCallback(object commandParameter, object callbackData);

CommandCallback class is as below.

public class CommandCallback:ICommand
    {
        private readonly Action<ICommandState> executeMethod;

        private readonly Func<ICommandState, bool> canExecuteMethod;

        public CommandCallback(Action<ICommandState> executeMethod)
            : this(executeMethod, null)
        {
        }

        public CommandCallback(Action<ICommandState> executeMethod, Func<ICommandState, bool> canExecuteMethod)
        {
            if (executeMethod == null)
            {
                throw new ArgumentNullException("executeMethod");
            }
            this.executeMethod = executeMethod;
            this.canExecuteMethod = canExecuteMethod;
        }  

        public bool CanExecute(object parameter)
        {
            return this.canExecuteMethod != null ? this.canExecuteMethod((ICommandState)parameter) : true;
        }

        public void Execute(object parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException("parameter","CommandCallback parameter cannot be null");
            }
            if (!(parameter is ICommandState))
            {
                throw new ArgumentException("expects a parameter of type ICommandState","parameter");
            }

            ICommandState state = (ICommandState)parameter;
            this.executeMethod.Invoke(state);
        }

        public event EventHandler CanExecuteChanged
        {
            add
            {
                CommandManager.RequerySuggested += value;
            }

            remove
            {
                CommandManager.RequerySuggested -= value;
            }
        }
    }

It’s working fine if it just to pop up the dialog box, but I want to wait for the result of the dialog and want to continue AccessDeny() function. For eg.

public void AccessDeny(ICommandState commandState)
            {
               1. processs
               2. open xaml window and wait for the dialogresult. (i.e Yes No or Cancel)
               3. Based on the result, continue processing.

            }

What could be the best way to do this work flow? Please advise. Thanks.

Answer 1

Read through User Interaction Patterns in this documentation.