A first chance exception of type 'System.Windows.Markup.Xaml

Question

How to open and close popup window from parent  in WPF using MVVM?

Please see my below code,tell me the solution for issue.

I create separate model,view,viewmodel for child usercontrol and parent usercontrol.

I try to open the popup window from parent window.I create separate view,viewmodel for child usercontrol and used inside the popup control of parent usercontrol.

I am getting issue and also how to close the popup window from the button click of child usercontrol.

I am getting this below issue:

-----------------------------

A first chance exception of type 'System.Windows.Markup.XamlParseException' occurred in PresentationFramework.dll

Additional information: 'No matching constructor found on type 'parentchild.View. ParentView.'. You can use the Arguments or FactoryMethod directives to construct this type.' Line number '9' and line position '10'.

If there is a handler for this exception, the program may be safely continued.

Here I am using WPF using MVVM pattern with Prism Framework.

MainWindow.xaml:

----------------

<Window x:Class="parentchild.MainWindow"

        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

         xmlns:my="clr-namespace:WpfLab.Controls;assembly=WpfLab.Controls"

            xmlns:local="clr-namespace:parentchild.View"

        Title="MainWindow" Height="768" Width="1280">

    <Grid>       

        <local:RumView></local:RumView>       

    </Grid>

</Window>

parentView.xaml:

------------

<UserControl x:Class="parentchild.View.parentView"

             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 

             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 

             xmlns:controls="clr-namespace:parentchild.View"

              xmlns:vm="clr-namespace:parentchild.ViewModel"

             mc:Ignorable="d" 

             d:DesignHeight="768" d:DesignWidth="1280">   

    <Grid x:Name="LayoutRoot" Width="1280" Height="768" Background="#2f3033">

        <Grid.Resources>

            <BooleanToVisibilityConverter x:Key="BoolToVis" />

        </Grid.Resources>

        <Canvas Margin="0.08,0.33,-0.081,0" VerticalAlignment="Top" Width="1280" Height="59" Visibility="{Binding canvasPlayerMain}" >

            

            <Button Width="144" Height="44" Content="Toss Card" Canvas.Left="14" Canvas.Top="8" BorderBrush="#FF496E00" Foreground="Black" IsEnabled ="{Binding tossButtonEnabled}" Command="{Binding tosscardCommand}">

              

            </Button>           

            <StackPanel>

                <Popup x:Name="popup" Width="100" Height="100" AllowsTransparency="True" IsOpen="{Binding IsPopupIsOpen}" Visibility="{Binding popupVisibility}">

                    <Grid Background="Transparent">

                        <controls:ChildWindowView></controls:ChildWindowView>

                    </Grid>

                </Popup>

            </StackPanel>

        </Canvas>

    </Grid>

</UserControl>

parentView.xaml.cs:

----------------

 public partial class parentView : UserControl

    {

        public parentView(ParentViewModel parentViewModel)

        {

            InitializeComponent();

            this.DataContext = parentViewModel;

        }

    }

ParentViewModel.cs:

----------------

    public class ParentViewModel : INotifyPropertyChanged

    {

         private readonly IEventAggregator eventAggregator;

         private RumModel currenrumModel;

        private string resultMessage;

        private bool _popupIsOpen;

        public RumViewModel(IEventAggregator eventAggregator)

        {

            currenrumModel = new RumModel();

            this.tosscardCommand = new DelegateCommand<object>(this.Execute, this.CanExecute);         

            if (eventAggregator == null) throw new ArgumentNullException("eventAggregator");

            this.eventAggregator = eventAggregator;

           

        }

        public bool IsPopupIsOpen

        {

            get { return _popupIsOpen; }

            set

            {

                _popupIsOpen = value;

                NotifyPropertyChanged("IsPopupIsOpen");

            }

        }

        public RumModel currentRum

        {

            get

            {

                return currenrumModel;

            }

            set

            {

                currenrumModel = value;

            }

        }

        public bool tossButtonEnabled

        {

            get { return this.currenrumModel.tossButtonIsEnabled; }

            set

            {

                this.currenrumModel.tossButtonIsEnabled = value;

                this.NotifyPropertyChanged("tossButtonEnabled");

            }

        }

        public Visibility popupVisibility

        {

            get { return this.currenrumModel.popupVisibility; }

            set

            {

                this.currenrumModel.popupVisibility = value;

                this.NotifyPropertyChanged("popupVisibility");

            }

        }

        #region commands

        public ICommand tosscardCommand { get; private set; }

        public ICommand cancelGameCommand { get; private set; }

        #endregion

        private bool CanExecute(object arg)

        {

            return true;

           

        }

        private void Execute(object arg)

        {

             popupVisibility = Visibility.Visible;

            IsPopupIsOpen = true;

            eventAggregator.GetEvent<PopupEvent>().Subscribe(PopupAction, ThreadOption.UIThread);

        }

       

        private void PopupAction(bool popup)

        {

            IsPopupIsOpen = popup;

        }

        private void RaiseCanExecuteChanged()

        {

            DelegateCommand<object> tosscommand = tosscardCommand as DelegateCommand<object>;          

            tosscommand.RaiseCanExecuteChanged();

           

        }

        #region INotifyPropertyChanged Members

        public event PropertyChangedEventHandler PropertyChanged;

        private void NotifyPropertyChanged(string propertyName)

        {

            if (this.PropertyChanged != null)

            {

                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

            }

        }

        #endregion

    }

ChildWindowView.xaml:

--------------------

<UserControl x:Class="parentchild.View.ChildWindowView"

             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 

             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 

                 xmlns:viewModels="clr-namespace:parentchild.ViewModel"

               xmlns:views="clr-namespace:parentchild.View"

             mc:Ignorable="d" 

             d:DesignHeight="500" d:DesignWidth="500">

    

    <Grid>

        <TextBlock HorizontalAlignment="Left" Margin="165,106,0,0" TextWrapping="Wrap" Text="Reschedule Timer" VerticalAlignment="Top" FontSize="21.333" Foreground="White" Width="174" Height="28"/>

        <TextBlock HorizontalAlignment="Left" Margin="37,199,0,0" TextWrapping="Wrap" Text="Set The Timer" VerticalAlignment="Top" FontSize="21.333" Foreground="White" Width="174" Height="28"/>

        <TextBox HorizontalAlignment="Left" Margin="252,199,0,0" TextWrapping="Wrap" Text="{Binding Path=setTimer}" VerticalAlignment="Top" Width="206" Height="38" />

        <Button Content="Submit" HorizontalAlignment="Left" Margin="252,278,0,0" VerticalAlignment="Top" Foreground="White" Width="122" Height="39" Background="Green" Command="{Binding SubmitCommand}"/>

    </Grid>

</UserControl>

ChildWindowView.xaml.cs:

--------------------

 public partial class ChildWindowView : UserControl

    {

        public ChildWindowView(ChildWindowView child)

        {

            InitializeComponent();

            this.DataContext = child;

        }

    }

ChildWindowViewModel.cs:

------------------------

  public class ChildWindowViewModel : INotifyPropertyChanged, IInteractionRequestAware

    {

        private ChildWindowModel currentChildWindow;

        private readonly IEventAggregator eventAggregator;

        private IService service;

        public ChildWindowViewModel(IEventAggregator eventAggregator,IService service)

        {

            currentChildWindow = new ChildWindowModel();

   this.eventAggregator = eventAggregator;

            this.service = service;

            this.SubmitCommand = new DelegateCommand<object>(this.OnSubmit, this.CanSubmit);

        }

        private void RaiseCanExecuteChanged()

        {

            DelegateCommand<object> command = SubmitCommand as DelegateCommand<object>;

            command.RaiseCanExecuteChanged();

        }

        public ChildWindowModel currentTimer

        {

            get

            {

                return currentTimer;

            }

            set

            {

                currentTimer = value;

            }

        }

        public string setTimer

        {

            get { return this.currentChildWindow.setTimer; }

            set

            {

                if (this.currentChildWindow.setTimer != value)

                {

                    this.currentChildWindow.setTimer = value;                 

                    NotifyPropertyChanged("setTimer");

                    RaiseCanExecuteChanged();

                }

            }

        }

        public string errMessage

        {

            get { return this.currentChildWindow.errMessage; }

            set

            {

                if (this.currentChildWindow.errMessage != value)

                {

                    this.currentChildWindow.errMessage = value;

                    NotifyPropertyChanged("errMessage");

                    RaiseCanExecuteChanged();

                }

            }

        }

        public ICommand SubmitCommand { get; private set; }

        private bool CanSubmit(object arg)

        {

            return true;

        }

        private void OnSubmit(object arg)

        {

            try

            {

                if (string.IsNullOrEmpty(setTimer))

                {

                    this.errMessage = "Please enter Rescheduler Timer value";

                }

                if (this.FinishInteraction != null)

                    this.FinishInteraction();

            }

            catch (Exception ex)

            {

                throw ex;

            }

        }

        public Action FinishInteraction { get; set; }

        public INotification Notification { get; set; }

        #region INotifyPropertyChanged Members

        public event PropertyChangedEventHandler PropertyChanged;

        private void NotifyPropertyChanged(string propertyName)

        {

            if (this.PropertyChanged != null)

            {

                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

            }

        }

        #endregion

    }