如何使用 mvvm 将 gridview 选定的行数据发送到另一个 window 与 wpf 中的文本框使用 mvvm

Question

I have tried a bunch of solutions about this problem on google but none seem to be helpful. I have a button on every row which when clicked open a new window with textboxes. This window should display the selected row cells data. I load the datagrid from mysql database.

VIEW

textboxes (XML) for second window

<Label Content="{Binding sFirstName, Mode=OneWay }" /> <Label Content="{Binding sLastName, Mode=OneWay }" />

Datagrid

<DataGrid ItemsSource="{Binding Path=MM}" SelectionMode="Extended" SelectedItem="{Binding SelectedItem}" >
<DataGrid.Columns>
<DataGridTextColumn Binding="{Binding Path=sFirstName}" />
<DataGridTextColumn Binding="{Binding Path=sLastName}" />
</DataGrid.Columns>

MODEL

public class MM : INotifyPropertyChanged
   {
       public event PropertyChangedEventHandler PropertyChanged;
       public void OnPropertyChanged([CallerMemberName]string PropertyName = null) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(PropertyName)); }

       private string _sFirstName, _sLastName;

       public string sFirstName { get { return _sFirstName; } set { if (_sFirstName != value) { _sFirstName = value; OnPropertyChanged("sFirstName"); } } }

       public string sLastName { get { return _sLastName; } set { if (_sLastName != value) { _sLastName = value; OnPropertyChanged("sLastName"); } } }

       public DataRowView SelectedRow
       {
           get { return SelectedRow; }
           set { SelectedRow = value; OnPropertyChanged("SelectedItem"); }
       }
}

VIEW MODEL

Public class MV : INotifyPropertyChanged
{
private ICommand cmdLoad;
public ICommand CmdLoad { get { if (cmdLoad == null) cmdLoad = new RelayCommand(p => OnLoad()); return cmdLoad; } }

private void OnLoad() { Load(); }

public ObservableCollection<FinTuitionM> finTuitionM { get; set; }
       
public ClrIdVMD()
{
Load();
}

public void Load()
{

}
}

Code behind (cs)

public partial class Home : Window
{
MV mv;
public Home()
{ InitializeComponent();
mv = new MV(); DataContext = mv;
}
}

Answer 1

You seem to be very confused, so I have prepared a small example of what I think you are trying to achieve.

I am guessing that you want to have a main view that is essentially read only, and you intend to use a popup to make changes. On this basis the View Model for the main window does not need to implement INotifyPropertyChanged. So a simple View Model would look like this:

public class MV 
{

    public ObservableCollection<MM> MMs { get; set; }

    private ICommand cmdShowDetails;
    public ICommand CmdShowDetails
    {
        get
        {
            if (cmdShowDetails == null) cmdShowDetails = new RelayCommand(p => ShowDetails());
            return cmdShowDetails;
        }
    }

    public void ShowDetails()
    {
        var detVM = new DetailsVM(SelectedItem);
        var dets = new DetailsWindow(detVM);
        dets.ShowDialog();
    }

    public MV()
    {
        MMs = new ObservableCollection<MM>
        {
            new MM{sFirstName = "Mickey", sLastName = "Mouse"},
            new MM{sFirstName = "Donald", sLastName = "Duck"},
            new MM{sFirstName = "Roger", sLastName = "Rabbit"},
        };
    }
    public MM SelectedItem { get; set; }

}

Notice that for demonstration purposes, I have loaded the ObservableCollection with some dummy data. In your case, this is replaced with data from the database.

The MM class that this refers to then looks something like this:

public class MM : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void RaisePropertyChangedEvent(string propertyName)
    {
        if (PropertyChanged != null)
        {
            var e = new PropertyChangedEventArgs(propertyName);
            PropertyChanged(this, e);
        }
    }

    private string firstName;
    public string sFirstName
    {
        get { return firstName; }
        set
        {
            if (firstName == value)
            {
                return;
            }
            firstName = value;
            RaisePropertyChangedEvent("sFirstName");
        }
    }
    private string lastName;
    public string sLastName
    {
        get { return lastName; }
        set
        {
            if (lastName == value)
            {
                return;
            }
            lastName = value;
            RaisePropertyChangedEvent("sLastName");
        }
    }
}

Notice that SelectedItem is in the View Model (MV) and is an object of class MM, so that when the second window is opened, the ShowDetails command can pass the selected details.

This therefore calls for a new very simple view model for the second (details) window:

public class DetailsVM
{
    public MM Detail { get; set; }

    public DetailsVM(MM detail)
    {
        Detail = detail;
    }
}

The main window grid xaml now looks like this:

<Grid>
    <DockPanel>
        <StackPanel DockPanel.Dock="Bottom" Orientation="Horizontal">
            <Button Content="Show Details" Command="{Binding CmdShowDetails}"></Button>
        </StackPanel>            
        <DataGrid ItemsSource="{Binding MMs}" SelectedItem="{Binding SelectedItem}"  AutoGenerateColumns="False">
            <DataGrid.Columns>
                <DataGridTextColumn Header="First Name" Binding="{Binding sFirstName}" />
                <DataGridTextColumn Header="Last Name" Binding="{Binding sLastName}" />
            </DataGrid.Columns>
        </DataGrid>
    </DockPanel>
</Grid>

Notice here that I only have one button at the bottom of the window to transfer the details. This is because the details come from the selected item, which is the highlighted row.

The code behind is simply:

public partial class MainWindow : Window
{
    private MV _mV;
    public MainWindow()
    {

        InitializeComponent();
        _mV = new MV();
        DataContext = _mV;
    }
}

Finally the xaml for the second (details) window

<Grid>
    <Grid.RowDefinitions>
        <RowDefinition Height="40*"/>
        <RowDefinition Height="40*"/>
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="70*"/>
        <ColumnDefinition Width="200*"/>
    </Grid.ColumnDefinitions>
    <Label Content="First Name" Grid.Column="0" Grid.Row="0" HorizontalAlignment="Right" VerticalAlignment="Center"/>
    <TextBox Text="{Binding Detail.sFirstName}" Grid.Column="1" Grid.Row="0" Width="150" Height="25" HorizontalAlignment="Left" />
    <Label Content="Last Name" Grid.Column="0" Grid.Row="1" HorizontalAlignment="Right" VerticalAlignment="Center"/>
    <TextBox Text="{Binding Detail.sLastName}" Grid.Column="1" Grid.Row="1" Width="150" Height="25" HorizontalAlignment="Left" />
</Grid>

Notice here that the binding is to Detail.sFirstName and Detail.sLastName. The DataContext is a DetailsVM object, which has a property Detail of type MM, hence sFirstName and sLastName are sub-properties of Detail.

This window also has a very simple code behind:

public partial class DetailsWindow : Window
{
    private DetailsVM _details;
    public DetailsWindow(DetailsVM details)
    {
        _details = details;
        DataContext = _details;
        InitializeComponent();
    }
}

If you now run this, you will find that changes made in the second window are automatically reflected back into the main window. In practice you will probably want Save and Cancel buttons in the second window.

I hope the above is sufficient to point you in the right direction!